import numpy as np
from scipy.misc import derivative
import math

def J(u):
    return pow(u,5) - pow(u,3) - 8*u + 3

def dJ(u):
    return 5 * pow(u,4) - 3 * u*u - 8


def d2J(u):
    return 20 * pow(u,3) - 6*u

def is_unimodal(a, b):
    for i in np.arange(start=a + 1, stop=b - 1, step=1):
        if derivative(lambda x: pow(x,5) - pow(x,3) - 8*x + 3, i, 2) < 0:
            return False
    return True

def is_convex(u1, u2, u3):
    delta_m = J(u1) - J(u2)
    delta_p = J(u3) - J(u2)
    return delta_m >= 0 and delta_p >= 0 and delta_m + delta_p > 0

def find_convex_points(a, b, eps):
    u1 = a
    u2 = u1 + eps
    u3 = u2 + eps
    while u3 <= b:
        if is_convex(u1, u2, u3):
            return np.around([u1, u2, u3], 3)
        u1 = u2
        u2 = u3
        u3 += eps

def parabola_min(u1, u2, u3):
    delta_m = J(u1) - J(u2)
    delta_p = J(u3) - J(u2)
    numerator = (u3 - u2) ** 2 * delta_m - (u2 - u1) ** 2 * delta_p
    denominator = 2 * ((u3 - u2) * delta_m + (u2 - u1) * delta_p)
    return u2 + numerator / denominator

def parabola_method(u1, u2, u3):
    global iterations
    while u2 != parabola_min(u1, u2, u3):
        w = parabola_min(u1, u2, u3)
        iterations += 1
        if w < u2:
            if J(w) < J(u2):
                u3 = u2
                u2 = w
            elif J(w) > J(u2):
                u1 = w
            else:
                if J(u1) > J(u2):
                    u3 = u2
                    u2 = w
                else:
                    u1 = w
        else:
            if J(w) < J(u2):
                u1 = u2
                u2 = w
            elif J(w) > J(u2):
                u3 = w
            else:
                if J(u3) > J(u2):
                    u1 = u2
                    u2 = w
                else:
                    u3 = w
    delta = 0.1
    if J(u2 + delta) < J(u2) and J(u2 - delta) < J(u2):
        return u2
    while not is_convex(u1, u2 - delta, u3) and delta > 0:
        iterations += 1
        delta -= 0.01
    return u2 - delta

def print_result(x, iterations):
    print("u* = " + str(x) + "; J(u*) = " + str(J(x)) + "; кол-во итераций: " + str(iterations))



def bisectionmethod():
    print("Введите a, b, e, d")
    a, b, e, d = input().split()
    a = float(a)
    b = float(b)
    e = float(e)
    d = float(d)
    n = 0
    if (is_unimodal(a,b)):
        while b-a >= e:
            n+=1
            u1 = (b+a-d)/2
            u2 = (b+a+d)/2
            J1 = J(u1)
            J2 = J(u2)
            if (J1 < J2):
                b = u2
            elif (J1 > J2):
                b = u1
            else:
                a = u1
                b = u2
        u_inf = (b+a)/2
        J_inf = J(u_inf)
        print("u* = " + str(u_inf) + "; J(u*) = " + str(J_inf) + "; кол-во итераций: " + str(n))
    else:
        print("Функция не унимодальна на введенном отрезке!")

def goldensectionmethod():
    print("Введите a, b, e")
    a, b, e = input().split()
    a = float(a)
    b = float(b)
    e = float(e)
    n = 0
    alfa = (math.sqrt(5) - 1)/2
    alfa1 = (3 - math.sqrt(5)) / 2
    u1 = a + alfa1*(b-a)
    u2 = a + alfa*(b-a)
    if (is_unimodal(a,b)):
        while b-a >= e:
            n+=1
            J1 = J(u1)
            J2 = J(u2)
            if (J1 < J2):
                b = u2
                u2 = u1
                J2 = J1
                u1 = a + alfa1*(b-a)
                J1 = J(u1)
            elif (J1 > J2):
                a = u1
                u1 = u2
                J1 = J2
                u2 = a +alfa*(b-a)
                J2 = J(u2)
            else:
                b = u2
                a = u1
                u1 = a + alfa1 * (b - a)
                u2 = a + alfa * (b - a)
                J1 = J(u1)
                J2 = J(u2)
        u_inf = (b + a) / 2
        J_inf = J(u_inf)
        print("u* = " + str(u_inf) + "; J(u*) = " + str(J_inf) + "; кол-во итераций: " + str(n))
    else:
        print("Функция не унимодальна на введенном отрезке!")

def newton(uk, eps):
    global iterations
    while abs(dJ(uk)) > eps:
        uk -= dJ(uk) / d2J(uk)
        iterations += 1
    return uk



A = -2
B = 2
print("1: Метод деления отрезка пополам.")
print("2: Метод золотого сечения.")
print("3: Метод парабол.")
print("4: Метод Ньютона.")
option = int(input())
if (option == 1):
    bisectionmethod()
elif (option == 2):
    goldensectionmethod()
elif (option == 3):
    if is_unimodal(A, B):
        iterations = 0
        convex_points = find_convex_points(A, B, 0.1)
        print("Найденная выпуклая тройка точек это", convex_points)
        u = parabola_method(convex_points[0], convex_points[1], convex_points[2])
        print_result(u, iterations)
else:
    if is_unimodal(A, B):
        iterations = 0
        u = newton(1, 0.01)
        print_result(u, iterations)