diff --git a/R1/TheParabolaMethod.py b/R1/TheParabolaMethod.py
new file mode 100644
index 0000000..6898646
--- /dev/null
+++ b/R1/TheParabolaMethod.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[25]:
+
+
+from numpy import sign
+from math import cos
+
+
+# In[26]:
+
+
+def f(x):
+    return cos(x)/x**2
+
+def find_convex_triple(x0, a, b, eps, i=1):
+    h = (b-a)/10
+    while (f(x0+h)>f(x0))&(f(x0-h)>f(x0)):
+        h /= 2
+        if (f(x0+h)-f(x0)<=eps)|(f(x0-h)-f(x0)<=eps):
+            return x0
+    if f(x0+h)<=f(x0):
+        x1 = x0 + h
+        x2 = x0 + h*2**(i)
+        f0 = f(x0)
+        while (f0<f(x1))|(f(x2)<f(x1))|(f0+f(x2)-2*f(x1)<=0):
+            i+=1
+            x1 = x0 + h*2**(i-1)
+            x2 = x0 + h*2**(i)
+    else:
+        x1 = x0 - h
+        x2 = x0 - h*2**(i)
+        f0 = f0
+        while (f0<f(x1))|(f(x2)<f(x1))|(f0+f(x2)-2*f(x1)<=0):
+            i+=1
+            x1 = x0 - h*2**(i-1)
+            x2 = x0 - h*2**(i)       
+    return (x0, x1, x2)
+            
+def get_top(x1, x2, x3, f1, f2, f3):
+    return (x1+x2)/2 + (f2-f1)*(x3-x2)*(x3-x1)/(2*(f1*(x2-x3)+f2*(x3-x1)+f3*(x1-x2)))
+
+def sort(points):
+    for i in range(3,0,-1):
+        for j in range(i):
+            if points[j][1] > points[j+1][1]:
+                points[j], points[j+1] = points[j+1], points[j]
+    return points
+
+
+# In[27]:
+
+
+def method(x0, eps, a, b, count=1):
+    try:
+        x1, x2, x3 = find_convex_triple(x0, a, b, eps)
+    except:
+        x0 = find_convex_triple(x0, a, b, eps)
+    x4 = get_top(x1, x2, x3, f(x1), f(x2), f(x3))
+    f1 = f(x1)
+    f2 = f(x2)
+    f3 = f(x3)
+    f4 = f(x4)
+    points = sort([(x1, f1), (x2, f2), (x3, f3), (x4, f4)])
+    print(f"Номер итерации: {count}   x1 = {points[0][0]:.4f} f1 = {points[0][1]:.4f}\n\t\t    x2 = {points[1][0]:.4f} f2 = {points[1][1]:.4f}\n\t\t    x3 = {points[2][0]:.4f} f3 = {points[2][1]:.4f}\n\t\t    x4 = {points[3][0]:.4f} f4 = {points[3][1]:.4f}\n")
+    while points[1][1] - points[0][1] >= eps:
+        if sign(points[1][0] - points[0][0]) == sign(points[2][0] - points[0][0]) == -sign(points[3][0] - points[0][0]):
+            count += 1
+            x3 = points[3][0]
+            x2 = points[1][0]
+            x1 = points[0][0]
+            x4 = get_top(x1, x2, x3, f(x1), f(x2), f(x3))
+            f1 = f(x1)
+            f2 = f(x2)
+            f3 = f(x3)
+            f4 = f(x4)
+            points = sort([(x1, f1), (x2, f2), (x3, f3), (x4, f4)])
+            print(f"Номер итерации: {count}   x1 = {x1:.4f} f1 = {f1:.4f}\n\t\t    x2 = {x2:.4f} f2 = {f2:.4f}\n\t\t    x3 = {x3:.4f} f3 = {f3:.4f}\n\t\t    x4 = {x4:.4f} f4 = {f4:.4f}\n")
+        else:
+            count += 1
+            x3 = points[2][0]
+            x2 = points[1][0]
+            x1 = points[0][0]
+            x4 = get_top(x1, x2, x3, f(x1), f(x2), f(x3))
+            f1 = f(x1)
+            f2 = f(x2)
+            f3 = f(x3)
+            f4 = f(x4)
+            points = sort([(x1, f1), (x2, f2), (x3, f3), (x4, f4)])
+            print(f"Номер итерации: {count}   x1 = {x1:.4f} f1 = {f1:.4f}\n\t\t    x2 = {x2:.4f} f2 = {f2:.4f}\n\t\t    x3 = {x3:.4f} f3 = {f3:.4f}\n\t\t    x4 = {x4:.4f} f4 = {f4:.4f}\n")
+    print(f"argmin(f) = {points[0][0]:.4f}")
+
+
+# In[28]:
+
+
+method(9, 0.0001, 7, 11)
+
+
+# In[ ]:
+
+
+
+
diff --git a/R1/ThePolylineMethod.py b/R1/ThePolylineMethod.py
new file mode 100644
index 0000000..6d1384c
--- /dev/null
+++ b/R1/ThePolylineMethod.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[196]:
+
+
+import numpy as np
+from math import cos, sin
+
+
+# In[248]:
+
+
+def f(x):
+    return cos(x)/x**2
+
+def df(x):
+    return -sin(x)/x**2 - 2*cos(x)/x**3
+
+def get_R(a, b, h):
+    X = np.arange(a, b+h, h)
+    R = abs(df(X[0]))
+    for i in range(X.size-1):
+        if abs(df(X[i])) >= R:
+            R = df(X[i])
+    return R + h
+
+def x(a, b, R):
+    return (a+b)/2 + (f(a)-f(b))/(2*R)
+
+def m(a, b, R):
+    return R*(a-b)/2 + (f(a)+f(b))/2
+
+
+# In[249]:
+
+
+def Method(a, b, h, eps, get_R, x, m, count=1, q=0, k=0):
+    R = get_R(a, b, h)
+    num = 0
+    digits = eps
+    while digits < 1:
+        digits *= 10
+        num += 1
+    X = np.array([])
+    M = np.array([])
+    x = x(a, b, R)
+    m = m(a, b, R)
+    while f(x) - m >= eps:
+        delta = (f(x)-m)/2/R
+        print(f"Номер итерации: {count}  x = {x:.{num}f}  f(x) = {f(x):.{num}f}  m = {m:.{num}f}  delta = {delta:.{num}f}")
+        X = np.append(X, [x-delta, x+delta])
+        M = np.append(M, [(f(x)+m)/2, (f(x)+m)/2])
+        q = M[0]
+        for i in range(M.size-1):
+            if M[i] <= q:
+                q = M[i]
+                k = i
+        M = np.delete(M, k)
+        x = X[k]
+        X = np.delete(X, k)
+        m = q
+        count += 1
+    print(f"Номер итерации: {count}  x = {x:.{num}f}  f(x) = {f(x):.{num}f}  R = {R:.{num}f}")
+
+
+# In[252]:
+
+
+Method(7, 11, 0.1, 0.0000001, get_R, x, m)
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/ConditionalGradientMethod.py b/Rn/ConditionalGradientMethod.py
new file mode 100644
index 0000000..96c46cc
--- /dev/null
+++ b/Rn/ConditionalGradientMethod.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[14]:
+
+
+import numpy as np
+from numpy.linalg import norm
+
+X = np.array([1, 1])
+D = np.array([(0,0),(2,0),(0,2)])
+
+def f(X):
+    return (X[0]**2 + X[1]**2 - 6*X[0] - 4*X[1]) 
+
+def grad(X):
+    return np.array([2*X[0] - 6,
+                     2*X[1] - 4])
+
+def fk(x, xk):
+    return np.dot(grad(xk), (x-xk))
+
+def y(X,a=0):
+    for i in range(2):
+        if fk(D[i], X) > fk(D[i+1], X):
+            a = D[i+1]
+    return a
+
+y(X)
+
+
+# In[15]:
+
+
+fk(y(X), X)
+
+
+# In[16]:
+
+
+lyambda = (1 + 5**(1/2))/2
+
+def GoldenRatio(Z, lyambda, A=0, B=1, eps1=0.000001, count=0):
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (f(Z + X*(y(Z)-Z))) > f(Z + Y*(y(Z)-Z)):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[17]:
+
+
+X
+
+
+# In[18]:
+
+
+eps = 0.00001
+count=1
+S = GoldenRatio(X,lyambda)
+XX = X + S*(y(X)-X)
+print(f"Нормер итерации: {count}  X = [{X[0]:.5f} {X[1]:.5f}]  y = [{y(X)[0]:.5f} {y(X)[1]:.5f}]  S = {S:.5f}  f(X) = {f(X):.5f}   fk = {fk(y(X), X)}")
+while(fk(y(X), X)<-eps):
+    S = GoldenRatio(X,lyambda)
+    X = X + S*(y(X)-X)
+    count+=1
+    print(f"Нормер итерации: {count}  X = [{X[0]:.5f} {X[1]:.5f}]  y = [{y(X)[0]:.5f} {y(X)[1]:.5f}]  S = {S:.5f}  f(X) = {f(X):.5f}   fk = {fk(y(X), X)}")
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/ConjugateGradientMethod.py b/Rn/ConjugateGradientMethod.py
new file mode 100644
index 0000000..b69356f
--- /dev/null
+++ b/Rn/ConjugateGradientMethod.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[58]:
+
+
+from math import e
+import numpy as np
+from numpy.linalg import norm
+
+
+# In[59]:
+
+
+def f(Z):
+    return (Z[0]**2 + 2*Z[1]**2 + e**(Z[0]**2 + Z[1]**2) - Z[0] + 2*Z[1])
+
+
+# In[60]:
+
+
+def gradient(Z):
+    return np.array([2*Z[0] * (1 + e**(Z[0]**2 + Z[1]**2)) - 1,
+                     2*Z[1] * (2 + e**(Z[0]**2 + Z[1]**2)) + 2])
+
+
+# In[61]:
+
+
+lyambda = (1 + 5**(1/2))/2
+
+def GoldenRatio(Z, lyambda, A=0, H=1, eps1=0.0000001, count=0):
+    if (f(Z - A*gradient(Z)/norm(gradient(Z))) < f(Z - H*gradient(Z)/norm(gradient(Z)))):
+        B = H
+    else:
+        while (f(Z - A*gradient(Z)/norm(gradient(Z))) >= f(Z - H*gradient(Z)/norm(gradient(Z)))):
+            H *=2
+            count+=1
+        B = H
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (f(Z - X*gradient(Z)/norm(gradient(Z))) > f(Z - Y*gradient(Z)/norm(gradient(Z)))):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[127]:
+
+
+# без обновления
+Z = (0, 0)
+eps2 = 0.000001
+count = 0
+h = gradient(Z)
+n = norm(h)
+gk_1 = h
+if (n <= eps2):
+    print(f"Нормер итерации: {count}  Z = [{Z[0]:.6f} {Z[1]:.6f}]  f(Z) = {f(Z):.6f}  |f'(Z)| = {n:.6f}")
+else:
+    while (n > eps2):
+        S = GoldenRatio(Z,lyambda)
+        Z = Z - S*h/norm(h)
+        gk = gradient(Z)
+        n = norm(gk)
+        beta = np.dot(gk_1 - gk, gk) / norm(gk_1)**2
+        h = gk - beta*h
+        gk_1 = gk
+        count+=1
+        print(f"Нормер итерации: {count} Z = [{Z[0]:.6f} {Z[1]:.6f}]  f(Z) = {f(Z):.6f}  |f'(Z)| = {n:.6f}")
+
+
+# In[128]:
+
+
+#  с обновлением
+Z = (0, 0)
+eps2 = 0.000001
+count = 0
+k = 2
+h = gradient(Z)
+n = norm(h)
+gk_1 = h
+while (n > eps2):
+    S = GoldenRatio(Z,lyambda)
+    Z = Z - S*h/norm(h)
+    count += 1
+    gk = gradient(Z)
+    n = norm(gk)
+    if count%k != 0:
+        beta = np.dot(gk_1 - gk, gk) / norm(gk_1)**2
+    else:
+        beta = 0
+    h = gk - beta*h
+    gk_1 = gk
+    print(f"Нормер итерации: {count} Z = [{Z[0]:.6f} {Z[1]:.6f}]  f(Z) = {f(Z):.6f}  |f'(Z)| = {n:.6f}")
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/GradientProjectionMethod.py b/Rn/GradientProjectionMethod.py
new file mode 100644
index 0000000..6e355ab
--- /dev/null
+++ b/Rn/GradientProjectionMethod.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import numpy as np
+from numpy.linalg import norm
+
+
+# In[2]:
+
+
+Z = np.array([1, -4])
+C = (1,1)
+gamma = 2
+k1=-1
+k2 = 1
+b1 = -2
+b2 = 2
+
+def direct0(x1, k1, gamma):
+    return k1*x1+gamma
+
+def direct1(x, k2, b1):
+    return k2*x+b1
+
+def direct2(x, k2, b2):
+    return k2*x+b2
+
+def Proj(Z, C, gamma, k2, b1, b2):
+    if (Z[0]<0)&(Z[1]<0):
+        print(0)
+        return np.array([0,0])
+    if (Z[1] <= direct1(Z[0], k2, b1))&(Z[0] >= 2):
+        print(1)
+        return np.array([2,0])
+    if (Z[1] >= direct2(Z[0], k2, b2))&(Z[1]>=2):
+        print(2)
+        return np.array([0,2])
+    if (Z[1]>direct1(Z[0], k2, b1))&(Z[1]<direct2(Z[0], k2, b2)):
+        if Z[1] > direct0(Z[0],k1,gamma):
+            print(3)
+            return np.array(Z + np.dot((gamma - np.dot(C, Z)) / norm(C)**2, C))
+        if (Z[1] <= direct0(Z[0],k1,gamma))&(Z[1] >= 0)&(Z[0] >= 0):
+            print(3)
+            return Z
+    if (Z[1]<0)&(Z[0]>=0)&(Z[0]<2):
+        return np.array([Z[0],0])
+    if (Z[1]<2)&(Z[1]>=0)&(Z[0]<0):
+        return np.array([0,Z[1]])
+    
+def f(Z):
+    return (Z[0]**2 + Z[1]**2 - 6*Z[0] - 4*Z[1]) 
+
+def gradient(Z):
+    return np.array([2*Z[0] - 6,
+                     2*Z[1] - 4])
+
+
+# In[3]:
+
+
+Proj(Z, C, gamma, k2, b1, b2)
+
+
+# In[4]:
+
+
+lyambda = (1 + 5**(1/2))/2
+
+def GoldenRatio(Z, lyambda, A=0, H=1, eps1=0.0000001, count=0):
+    if (f(Z - A*gradient(Z)/norm(gradient(Z))) < f(Z - H*gradient(Z)/norm(gradient(Z)))):
+        B = H
+    else:
+        while (f(Z - A*gradient(Z)/norm(gradient(Z))) >= f(Z - H*gradient(Z)/norm(gradient(Z)))):
+            H *=2
+            count+=1
+        B = H
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (f(Z - X*gradient(Z)/norm(gradient(Z))) > f(Z - Y*gradient(Z)/norm(gradient(Z)))):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[5]:
+
+
+eps2 = 0.000001
+count = 0
+S = GoldenRatio(Z,lyambda)
+Pz = Proj(Z-S*gradient(Z)/norm(gradient(Z)), C, gamma, k2, b1, b2)
+print(f"Дано:  Pz = {Pz}  S = {S:.4f}  |f'(Z)| = {norm(gradient(Z)):.4f}  |Z-Pz| = {norm(Z - Pz)}")
+while (norm(gradient(Z)) >= eps2) & (norm(Z - Pz) >= eps2):
+    Z = Pz
+    S = GoldenRatio(Z,lyambda)
+    Pz = Proj(Z-S*gradient(Z)/norm(gradient(Z)), C, gamma, k2, b1, b2)
+    print(Pz)
+    count += 1
+    print(f"Нормер итерации: {count}  Pz = [{Pz[0]:.4f} {Pz[1]:.4f}]  S = {S:.4f}  f(Z) = {f(Z):.4f}  |f'(Z)| = {norm(gradient(Z)):.4f}  |Z-Pz| = {norm(Z - Pz):.4f}")
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/Newton'sMethod.py b/Rn/Newton'sMethod.py
new file mode 100644
index 0000000..4e92f21
--- /dev/null
+++ b/Rn/Newton'sMethod.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[3]:
+
+
+from math import e
+import numpy as np
+from numpy.linalg import norm
+
+
+# In[4]:
+
+
+Z = np.array([1,2])
+
+
+# In[83]:
+
+
+def f(Z):
+    return (Z[0]**2 + 2*Z[1]**2 + e**(Z[0]**2 + Z[1]**2) - Z[0] + 2*Z[1])
+
+def grad1(Z):
+    return np.array([2*Z[0] * (1 + e**(Z[0]**2 + Z[1]**2)) - 1,
+                     2*Z[1] * (2 + e**(Z[0]**2 + Z[1]**2)) + 2])
+
+def grad2(Z):
+    return np.array([[2*(1 + e**(Z[0]**2 + Z[1]**2)) + 2*Z[0] * 2*Z[0] * e**(Z[0]**2 + Z[1]**2),
+                     2*Z[0] * 2*Z[1] * (1 + e**(Z[0]**2 + Z[1]**2))],
+                     [2*Z[0] * 2*Z[1] * (1 + e**(Z[0]**2 + Z[1]**2)),
+                     2*(2 + e**(Z[0]**2 + Z[1]**2)) + 2*Z[1] * 2*Z[1] * e**(Z[0]**2 + Z[1]**2)]])
+
+
+# In[84]:
+
+
+def arg(X):
+    return np.linalg.solve(grad2(Z), np.dot(grad2(Z), Z) - X * grad1(Z))
+
+lyambda = (1 + 5**(1/2))/2
+
+def GoldenRatio(Z, lyambda, A=0, B=1, eps1=0.00000001, count=0):
+
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (f(arg(X)) > f(arg(Y))):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[85]:
+
+
+eps = 0.0000000001
+count = 0
+while (norm(grad1(Z)) >= eps):
+    #Z = Z - np.dot(np.linalg.inv(grad2(Z)), grad1(Z))
+    #S = GoldenRatio(Z, lyambda)
+    Z = arg(1)
+    count += 1
+    print(f"Нормер итерации: {count} Z = [{Z[0]:.10f} {Z[1]:.10f}]  f(Z) = {f(Z):.10f}  |f'(Z)| = {norm(grad1(Z)):.10f}")
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/SteepestDescent.py b/Rn/SteepestDescent.py
new file mode 100644
index 0000000..29bf4c4
--- /dev/null
+++ b/Rn/SteepestDescent.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+from math import e
+import numpy as np
+from numpy.linalg import norm
+
+
+# In[2]:
+
+
+Z = np.array([2,4])
+
+
+# In[3]:
+
+
+def f(Z):
+    return (Z[0]**2 + 2*Z[1]**2 + e**(Z[0]**2 + Z[1]**2) - Z[0] + 2*Z[1])
+
+
+# In[4]:
+
+
+def gradient(Z):
+    return np.array([2*Z[0] * (1 + e**(Z[0]**2 + Z[1]**2)) - 1,
+                     2*Z[1] * (2 + e**(Z[0]**2 + Z[1]**2)) + 2])
+
+
+# In[4]:
+
+
+lyambda = (1 + 5**(1/2))/2
+
+
+# In[5]:
+
+
+def GoldenRatio(Z, lyambda, A=0, H=1, eps1=0.0000001, count=0):
+    if (f(Z - A*gradient(Z)/norm(gradient(Z))) < f(Z - H*gradient(Z)/norm(gradient(Z)))):
+        B = H
+    else:
+        while (f(Z - A*gradient(Z)/norm(gradient(Z))) >= f(Z - H*gradient(Z)/norm(gradient(Z)))):
+            H *=2
+            count+=1
+        B = H
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (f(Z - X*gradient(Z)/norm(gradient(Z))) > f(Z - Y*gradient(Z)/norm(gradient(Z)))):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[6]:
+
+
+eps2 = 0.000001
+count = 0
+print(f"Дано:   Z = {Z}  f(Z) = {f(Z):.6f}  |f'(Z)| = {norm(gradient(Z)):.6f}")
+if (norm(gradient(Z)) <= eps2):
+    print(f"Нормер итерации: {count}  Z = [{Z[0]:.6f} {Z[1]:.6f}]  f(Z) = {f(Z):.6f}  |f'(Z)| = {norm(gradient(Z)):.6f}")
+else:
+    while (norm(gradient(Z)) > eps2):
+        S = GoldenRatio(Z,lyambda)
+        Z = Z - S*gradient(Z)/norm(gradient(Z))
+        count+=1
+        print(f"Нормер итерации: {count} Z = [{Z[0]:.6f} {Z[1]:.6f}]  f(Z) = {f(Z):.6f}  |f'(Z)| = {norm(gradient(Z)):.6f}")
+
+
+# In[ ]:
+
+
+
+
diff --git a/Rn/ThePenaltyMethod.py b/Rn/ThePenaltyMethod.py
new file mode 100644
index 0000000..36058be
--- /dev/null
+++ b/Rn/ThePenaltyMethod.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import numpy as np
+from numpy.linalg import norm
+from math import e
+
+
+# In[2]:
+
+
+def f(Z):
+    return (Z[0]**2 + Z[1]**2 - 6*Z[0] - 4*Z[1])
+
+
+def gradient(Z):
+    return np.array([2*Z[0] - 6,
+                     2*Z[1] - 4])
+
+
+def fi(Z, i):
+    if i == 0:
+        return Z[0] + Z[1] - 2
+    elif i == 1:
+        return -Z[0]
+    elif i == 2:
+        return -Z[1]
+    
+
+def H(Z, k=3, p=2):
+    sigma=0
+    for i in range(k):
+        f_i = fi(Z, i)
+        if f_i > 0:
+            sigma += f_i**p
+    return sigma
+
+
+def dH(Z, k=3, p=2):
+    sigma = np.array([0, 0])
+    for i in range(k):
+        if fi(Z, i) > 0:
+            if i == 0:
+                sigma[0] += p*(Z[0] + Z[1] - 2)**(p-1)
+                sigma[1] += p*(Z[0] + Z[1] - 2)**(p-1)
+            elif i == 1:
+                sigma[0] += -p*(-Z[0])**(p-1)
+            elif i == 2:
+                sigma[1] += -p*(-Z[1])**(p-1)
+    return sigma
+
+
+def fn(Z, a):
+    return f(Z) + a*H(Z)
+
+
+def dfn(Z, a):
+    return np.array([2*Z[0] - 6 + a*dH(Z)[0], 
+                     2*Z[1] - 4 + a*dH(Z)[1]])
+
+
+# проба
+def fn(Z, a, k=3, p=2):
+    sigma = 0
+    for i in range(k):
+        if fi(Z, i) > 0:
+            if i == 0:
+                sigma += (Z[0] + Z[1] - 2)**(p)
+            elif i == 1:
+                sigma += (-Z[0])**(p)
+            elif i == 2:
+                sigma += (-Z[1])**(p)
+    return (Z[0]**2 + Z[1]**2 - 6*Z[0] - 4*Z[1] + a*sigma)
+
+
+# проба
+def dfn(Z, a, k=3, p=2):
+    sigma = np.array([2*Z[0] - 6, 2*Z[1] - 4])
+    for i in range(k):
+        if fi(Z, i) > 0:
+            if i == 0:
+                sigma[0] += p*a*(Z[0] + Z[1] - 2)**(p-1)
+                sigma[1] += p*a*(Z[0] + Z[1] - 2)**(p-1)
+            elif i == 1:
+                sigma[0] += -p*a*(-Z[0])**(p-1)
+            elif i == 2:
+                sigma[1] += -p*a*(-Z[1])**(p-1)
+    return np.array([sigma[0], sigma[1]])
+        
+    
+lyambda = (1 + 5**(1/2))/2
+def GoldenRatio(Z, a, lyambda, A=0, H=0.00000001, eps1=0.000000001, count=0):
+    if (fn((Z - A*dfn(Z, a)/norm(dfn(Z, a))), a) < fn((Z - H*dfn(Z, a)/norm(dfn(Z, a))), a)):
+        B = H
+    else:
+        while (fn((Z - A*dfn(Z, a)/norm(dfn(Z, a))), a) >= fn((Z - H*dfn(Z, a)/norm(dfn(Z,a))), a)):
+            H *= 2
+            count += 1
+        B = H
+    delta = (B-A)/lyambda**2
+    X = A + delta
+    Y = B - delta
+    if (abs(B - A) <= 2 * eps1):
+        S = (A+B)/2
+    else:
+        while (abs(B - A) > 2 * eps1):
+            if (fn((Z - X*dfn(Z, a)/norm(dfn(Z, a))), a) > fn((Z - Y*dfn(Z, a)/norm(dfn(Z, a))), a)):
+                A = X;
+                X = Y;
+                Y = A + B - X;
+            else:
+                B = Y;
+                Y = X;
+                X = A + B - Y;
+        S = (A+B)/2
+    return S
+
+
+# In[3]:
+
+
+def SDescent(Z, a):
+    eps2 = 0.00001
+    count = 0
+    if (norm(dfn(Z, a)) <= eps2):
+        print(f"Нормер итерации: {count}    Z = [{Z[0]:.5f} {Z[1]:.5f}]   |fn'(Z)| = {norm(dfn(Z, a)):.5f}   fn(Z) = {fn(Z, a):.5f}   f(Z) = {f(Z):.5f}")
+    else:
+        while (norm(dfn(Z, a)) > eps2):
+            S = GoldenRatio(Z, a, lyambda)
+            Z = Z - S*dfn(Z, a)/norm(dfn(Z, a))
+            count+=1
+            print(f"Нормер итерации: {count}    Z = [{Z[0]:.5f} {Z[1]:.5f}]   |fn'(Z)| = {norm(dfn(Z, a)):.5f}   fn(Z) = {fn(Z, a):.5f}   f(Z) = {f(Z):.5f}")
+    return Z
+
+
+# In[4]:
+
+
+Z = np.array([1, 2])
+a = e
+count = 1
+eps3 = 0.001
+if H(Z)**(1/2) >= eps3:
+    print(f"\nШаг по штрафу {count}:   a = {a:.3f}     x = [{Z[0]:.3f} {Z[1]:.3f}]     H(x)^1/2 = {H(Z)**(1/2):.3f}\n")
+Z = SDescent(Z, a)
+while H(Z)**(1/2) >= eps3:
+    count += 1
+    a *= e
+    print(f"\nШаг по штрафу {count}:   a = {a:.3f}     x = [{Z[0]:.3f} {Z[1]:.3f}]     H(x)^1/2 = {H(Z)**(1/2):.3f}\n")
+    Z = SDescent(Z, a)
+print(f"\nРезультат:   x = [{Z[0]:.3f} {Z[1]:.3f}]     H(x)^1/2 = {H(Z)**(1/2):.3f}\n")
+
+
+# In[ ]:
+
+
+
+