НСАУ. Метод Ньютона и простой итерации

import numpy as np
from scipy.optimize import fsolve
 
def eq1(p):
    x, y = p
    return (np.tan(x*y) - x*x, 0.7*x*x + 2*y*y - 1)
x,y = fsolve(eq1, (1,0))  # (1,0) - область поиска решений
print('Ответ: ', x,y)
 
print('Проверка решения: ', eq1((x,y)))

def jacobian_exercise(x, y):
    return [[(y/(np.cos(x*y)**2))-2*x, (x/(np.cos(x*y)**2))],
            [1.4*x, 4*y]]
 
jotinha  = (jacobian_exercise(1,2))
 
def function_exercise(x,y):
    return [np.tan(x * y) - x * x, 0.7 * x * x + 2 * y * y - 1]
 
bezao = (function_exercise(1,2))
 
def x_delta_by_gauss(J,b):
 
    return np.linalg.solve(J,b)
 
#x_delta_test = x_delta_by_gauss(jotinha,bezao)
 
def x_plus_1(x_delta,x_previous):
 
    x_next = x_previous + x_delta
 
    return x_next
 
#print (x_plus_1(x_delta_test,[1,2,3]))
 
def newton_method(x_init):
 
    first = x_init[0]
 
    second = x_init[1]
 
    jacobian = jacobian_exercise(first, second)
 
 
    vector_b_f_output = function_exercise(first, second)
 
    x_delta = x_delta_by_gauss(jacobian, vector_b_f_output)
 
    x_plus_1 = x_delta + x_init
 
    return x_plus_1
 
def iterative_newton(x_init):
 
    counter = 0
 
    x_old = x_init
 
    x_new = newton_method(x_old)
 
 
    diff = np.linalg.norm(x_old-x_new)
 
 
    while diff>1e-5:
 
        counter += 1
 
        x_new = newton_method(x_old)
 
        diff = np.linalg.norm(x_old-x_new)
 
        x_old = x_new
 
    convergent_val = x_new
 
    return convergent_val
 
print(iterative_newton([1,2]))

def negative(lst):
    return [-i for i in lst]

    vector_b_f_output = negative(function_exercise(first, second))

plt.scatter(function_exercise(1, 0))
plt.show()

plt.scatter(*function_exercise(1, 0))

def eq2(p):
    x, y, z = p
    return (x**2 + y**2 + z**2 - 3, 2*x**2 + y**2 - 4*z - 1, 3*x**2 - 4*y + z**2)
 
 
x, y, z = fsolve(eq2, (1, 1, 1))

def eq2(p):
    x, y, z = p
    return (x**2 + y**2 + z**2 - 3, 2*x**2 + y**2 - 4*z - 1, 3*x**2 - 4*y + z**2)

x, y, z = fsolve(eq2, (1, 1, 1), xtol=1e-3)

def jacobian_exercise(x, y):
    return [[(y / (np.cos(x * y) ** 2)) - 2 * x, (x / (np.cos(x * y) ** 2))],
            [1.4 * x, 4 * y]]
 
 
jotinha = (jacobian_exercise(1, 1))
 
 
def negative(lst):
    return [-i for i in lst]
 
 
def function_exercise(x, y):
    return [np.tan(x * y) - x * x, 0.7 * x * x + 2 * y * y - 1]
 
 
bezao = (function_exercise(1, 0))
 
 
def x_delta_by_gauss(J, b):
    return np.linalg.solve(J, b)
 
 
x_delta_test = x_delta_by_gauss(jotinha, bezao)
 
 
def x_plus_1(x_delta, x_previous):
    x_next = x_previous + x_delta
    return x_next
 
 
print("Errors: ", x_plus_1(x_delta_test, [1, 1]))
 
 
def newton_method(x_init):
    first = x_init[0]
    second = x_init[1]
    jacobian = jacobian_exercise(first, second)
    vector_b_f_output = negative(function_exercise(first, second))
    x_delta = x_delta_by_gauss(jacobian, vector_b_f_output)
    x_plus_1 = x_delta + x_init
    return x_plus_1
 
 
def iterative_newton(x_init):
    counter = 0
    x_old = x_init
    x_new = newton_method(x_old)
    diff = np.linalg.norm(x_old - x_new)
    while diff > 1e-5:
        counter += 1
 
        x_new = newton_method(x_old)
 
        diff = np.linalg.norm(x_old - x_new)
 
        x_old = x_new
 
    convergent_val = x_new
    print("Количество итерации: ", counter)
    return convergent_val
 
 
print("Result: ", iterative_newton([1, 1]))
 
 
def graphic1():
    fig1, ax = plt.subplots(figsize=(8, 6))
    plt.ylabel(r'$y$', fontsize=13, fontname='Arial', color='white')
    plt.xlabel(r'$x$', fontsize=13, fontname='Arial', color='white')
    plt.grid(which='both', linewidth=1.5, linestyle='-', color='gray')
    ax.tick_params(which='major', length=8, width=2)
    ax.tick_params(which='minor', length=8, width=2)
    ax.minorticks_on()
    ax.grid(which='major',
            linewidth=2)
    ax.grid(which='minor',
            linestyle=':')
    plt.scatter(*function_exercise(1, 0), color="blue", marker="s", edgecolors='yellow', linewidth=3, s=60, hatch='+o')
    plt.plot(*function_exercise(1, 0), color="blue")
    legend = plt.legend(['Начальное приближение'], loc='upper right', shadow=True, fontsize='x-large',
                        frameon=True, title="Легенда", title_fontsize=15, framealpha=1)
    frame = legend.get_frame()
    frame.set_facecolor('black')
    frame.set_edgecolor('red')
    plt.title("Начальное приближение")
    mplcyberpunk.add_gradient_fill(alpha_gradientglow=0.5)
    mplcyberpunk.add_glow_effects()
    plt.show()
    fig1.savefig('newton_point.png', dpi=300, bbox_inches='tight')
 
 
graphic1()

import sys
import numpy as np
import matplotlib.pyplot as plt
import mplcyberpunk
from scipy.optimize import fsolve

UserWarning: Attempting to set identical bottom == top == -0.30000000000000004 results in singular transformations; automatically expanding.
  im = ax.imshow(z,

   plt.plot(*function_exercise(1, 0), color="blue")

def equations(p):
    x, y = p
    return (np.tan(x * y) - x * x, 0.7 * x * x + 2 * y * y - 1)
 
x, y =  fsolve(equations, (1, 1), xtol=1e-5)
print(f'Answers: {x=}, {y=}')
print(f'Check answers:', equations((x, y)))
 
 
def function_exercise(xy):
    x, y = xy
    return [np.tan(x * y) - x * x,
            0.7 * x * x + 2 * y * y - 1]
 
def jacobian_exercise(xy):
    x, y = xy
    return [[(y / (np.cos(x * y) ** 2)) - 2 * x, (x / (np.cos(x * y) ** 2))],
            [1.4 * x, 4 * y]]
 
def iter_newton(X, function, jacobian, imax = 1e6, tol = 1e-5):
    i = 0
    for i in range(int(imax)):
        J = jacobian(X)  # calculate jacobian J = df(X)/dY(X)
        Y = function(X)  # calculate function Y = f(X)
        dX = np.linalg.solve(J, Y)  # solve for increment from JdX = Y
        X -= dX  # step X by dX
        if np.linalg.norm(dX) < tol:  # break if converged
            i += 1
            print('Converged')
            break
    print(f'Number of iterations: {i=}')
    return X
 
X_0 = np.array([1, 1], dtype=float)
print(iter_newton(X_0, function_exercise, jacobian_exercise))

X0 = 1
Y0 = 1
x, y = symbols('x y')
F1 = atan(x*x) / y
F2 = sqrt(1-0.7*x*x) / 2
fi1x = diff(F1, x)
fi1y = diff(F1, y)
fi2x = diff(F2, x)
fi2y = diff(F2, y)
print(f'{fi1x=} \t {fi1y=} \n {fi2x=} \t {fi2y}')
while abs(F1 - X0) <= 1e-5 and abs(F2 - Y0) <= 1e-5:
    if (abs(fi1x) + abs(fi1y)) and (abs(fi2x) + abs(fi2y)) < 1:
        print("Converged")
    else:
        print("-")