Sharedidz.ipynbOpen in CoCalc
#задание1
N = 15 
import numpy as np
import random
li = []
for i in range(N):
    li += [random.randint(-9, 9)] 
print(li)
[-7, -6, -9, 0, 0, 5, 7, 7, 4, 0, -4, 1, 3, -5, -5]
index = 0
chet = []
for i in range(len(li)):
    if li[i]%3 == 0: 
        index += 1 
    if li[i]%2 == 0: 
        chet += [li[i]]
print(chet)
[-6, 0, 0, 4, 0, -4]
index
6
sred = sum(chet)/len(chet);sred
-1.0
[index]+li+[sred]
[6, -7, -6, -9, 0, 0, 5, 7, 7, 4, 0, -4, 1, 3, -5, -5, -1.0]
#задание2
nabor = "ab13cdlj5b3l33j38f8gg9s99g90h20hh9d9s75f7s57f97sf8f8s9779691g788gd8g8df98gdf79gdg4d494d59dud8ggdf9gd0gdg949994999444989489489jv4dfjvfv6l7co29"
chisla = [] 
num = 0
for i in nabor:
    if i.isalpha():
        chisla += [num]
        num = 0
        continue
    if i.isdigit():
        num += 1
        

print(chisla)
[0, 0, 2, 0, 0, 0, 1, 1, 2, 2, 1, 0, 1, 2, 2, 2, 0, 1, 1, 2, 1, 2, 2, 0, 1, 1, 7, 3, 0, 1, 1, 0, 2, 0, 0, 2, 0, 0, 1, 3, 2, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 21, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0]
max(chisla)
21
#задание3
			N = 5
M = 5
n = 1
mat = np.reshape([1 for x in range(N) for x in range(M)],(N,M));mat
l = np.array([0,0,0,0,0])
L = np.reshape(l,(5,1));print(mat, '\n', L)
[[1 1 1 1 1] [1 1 1 1 1] [1 1 1 1 1] [1 1 1 1 1] [1 1 1 1 1]] [[0] [0] [0] [0] [0]]
new = np.hstack((mat, L));new
array([[1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 0]])
nn = new.transpose();nn
array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [0, 0, 0, 0, 0]])
nn[n] =  nn[len(nn) - 1]; nn[len(nn) - 1] = nn[0]
nn
array([[1, 1, 1, 1, 1], [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]])
nn.transpose()
array([[1, 0, 1, 1, 1, 1], [1, 0, 1, 1, 1, 1], [1, 0, 1, 1, 1, 1], [1, 0, 1, 1, 1, 1], [1, 0, 1, 1, 1, 1]])
#задание4
A = np.reshape([np.random.randint(2,6) for x in range(60)],(4,15));A = np.array(A);A
array([[3, 4, 5, 3, 2, 3, 2, 3, 4, 2, 5, 4, 4, 5, 5], [3, 3, 5, 2, 2, 5, 3, 4, 3, 2, 2, 2, 5, 4, 4], [5, 2, 5, 5, 5, 2, 4, 5, 2, 4, 3, 2, 5, 3, 3], [4, 3, 4, 3, 2, 5, 3, 3, 3, 4, 5, 5, 2, 3, 5]])
n = []
m = []
for i in range(len(A)):
    n = []
    for x in A[i]:
        if x == 3:
            n += [x]
    m +=[ n]
print(m)
[[3, 3, 3, 3], [3, 3, 3, 3], [3, 3, 3], [3, 3, 3, 3, 3, 3]]
n = []
m = []
for i in range(len(A)):
    n = []
    for x in A[i]:
        if x == 3:
            n += [x]
    m +=[ len(n)]
m
[4, 4, 3, 6]
en = list(enumerate(m));en 
[(0, 4), (1, 4), (2, 3), (3, 6)]
min(m)
3
di = dict(en);di
{0: 4, 1: 4, 2: 3, 3: 6}
di[2]
3
 res = {v: k for k, v in di.items()}
res
{3: 2, 4: 1, 6: 3}
res[min(m)]
2
k = []
l = []
for i in range(len(A)):
    k = []
    for j in range(len(A[i])):
        if A[i][j] == 3:
            k += [j]
    l +=[ k]
A[i]
array([4, 3, 4, 3, 2, 5, 3, 3, 3, 4, 5, 5, 2, 3, 5])
l
[[0, 3, 5, 7], [0, 1, 6, 8], [10, 13, 14], [1, 3, 6, 7, 8, 13]]
lo = list(map(lambda x:len(x),l));lo 
[4, 4, 3, 6]
minm = lo[0]
pos = 0
for i in range(len(lo)):
    print("min=", minm, "pos=", pos)
min= 4 pos= 0 min= 4 pos= 0 min= 4 pos= 0 min= 4 pos= 0

#3адание 5

import matplotlib.pyplot as pl
%matplotlib inline
func = lambda x:  (1-x)/x-3*np.cos(4*x)
x = np.linspace(0, 5, 100)
pl.plot(x,func(x))
pl.annotate('root', xy=(1.15, 0), xytext=(1.4, 4), arrowprops=dict(facecolor='black', shrink=0.05),)
pl.grid(1)
pl.show()
/usr/local/lib/python3.5/dist-packages/ipykernel/__main__.py:1: RuntimeWarning: divide by zero encountered in true_divide if __name__ == '__main__':
import time 
t1 = time.clock()
def search(f, stP, finP):
    mP=average(stP, finP)
    if nearcl(stP, finP):
        return mP
    test = f(mP)
    if test>0:
        return search(f, stP, mP)
    elif test < 0:
        return search(f, mP, finP)
    return mP
def average(x, y):
    return (x+y)/2

def nearcl(x, y):
    if abs(x-y)<0.00001:
        return 1
    return 0
def halfInterval(f, a ,b):
    aVal=f(a)
    bVal=f(b)
    if aVal>0 and bVal<0:
        return search(f, b, a)
    elif aVal<0 and bVal>0:
        return search(f, a, b)
    else:
        return 0
t2 = time.clock() 
print(t2-t1)
0.025542000000000176

halfInterval(func, 1, 2) ###########################5
1.1662178039550781

func = lambda x:  (1-x)/x-3*np.cos(4*x)# метод хорд
import time 
t1 = time.clock() 
def chord(sp, fp, ep):
    while(abs(fp - sp) > ep):
        sp = fp - (fp - sp)*func(fp)/(func(fp) - func(sp)) 
        fp = sp + (sp - fp)*func(sp)/(func(sp) - func(fp))
    return fp
t2 = time.clock() 
print(t2-t1)
0.00014199999999986446




chord(1, 2, 0.000001)########################
2.0054727407943655
func = lambda x: np.tan(2.5*x)-5*x    #касательных
dif = lambda x: 2.5/np.cos(2.5*x)**2-5
def kas(x0, func, dif, e):
    while 1:
        x1 = x0 - (func(x0) / dif(x0))
        if abs(x1 - x0) < e:
            return x1
        x0 = x1
kas(0.4, func, dif, 0.0001)#######################
0.4662244740831599
func = lambda x: np.tan(2.5*x)-5*x #простой итерации
dif = lambda x: 2.5/np.cos(2.5*x)**2-5
def iter(sp, fp, ep):
    fp = sp - func(sp)/dif(sp)
    while(abs(fp - sp) > ep):
        sp = fp - func(fp)/dif(fp)
        fp = sp - func(sp)/dif(sp)
    return fp
iter(0.45,0.5,0.001)##################
0.4662244941232622

задание 6

import numpy as np
import numpy.linalg as li
A = [[10,2,6], [1,10,9], [2,-7,-10]];A
b = np.array([2.8,7,-17]);b
array([ 2.8, 7. , -17. ])
C = np.reshape([-A[i][j]/A[i][i] for i in range(len(A[0])) for j in range(len(A))],(3,3)) + np.eye(3);print(C)
d = [b[i]/A[i][i] for i in range(len(b))];d
[[ 0. -0.2 -0.6] [-0.1 0. -0.9] [ 0.2 -0.7 0. ]]
[0.27999999999999997, 0.7, 1.7]
li.solve(A,b) #решили для проверки
array([-0.95882353, -1.51764706, 2.57058824])
def lighiter(q1, q2, q3, m=0, ep=0.001): #простой итерации
    ind = 0
    q = np.array([q1,q2,q3])
    x = C.dot(q) + d
    while(abs(x[0] - q[0]) > ep and abs(x[1] - q[1]) > ep and abs(x[2] - q[2]) > ep ):
        q = C.dot(x) + d
        x = C.dot(q) + d
        m = m + 1
        ind += 1
    return (x, ind)
    print (m)
q = li.solve(A,b)
x = C.dot(q) + d;x
array([-0.95882353, -1.51764706, 2.57058824])
lighiter(0, 0, 0, 0.0001) ###########################
(array([-0.95822136, -1.51662799, 2.57032029]), 12)
def zeid(q1, q2, q3, ep=0.001): #метод Зейделя
    ind = 0
    q = np.array([q1,q2,q3])
    x1 = C[0][0]*q1 + C[0][1]*q2 + C[0][2]*q3 + d[0]
    x2 = C[1][0]*x1 + C[1][1]*q2 + C[1][2]*q3 + d[1]
    x3 = C[2][0]*x1 + C[2][1]*x2 + C[2][2]*q3 + d[2]
    while(abs(x1 - q1) > ep and abs(x2 - q2) > ep and abs(x3 - q3) > ep):
        x1 = C[0][0]*q1 + C[0][1]*q2 + C[0][2]*q3 + d[0]
        x2 = C[1][0]*x1 + C[1][1]*q2 + C[1][2]*q3 + d[1]
        x3 = C[2][0]*x1 + C[2][1]*x2 + C[2][2]*q3 + d[2]
        q1 = C[0][0]*x1 + C[0][1]*x2 + C[0][2]*x3 + d[0]
        q2 = C[1][0]*q1 + C[1][1]*x2 + C[1][2]*x3 + d[1]
        q3 = C[2][0]*q1 + C[2][1]*q2 + C[2][2]*x3 + d[2]
        ind += 1
    return [[x1, x2, x3], ind]
zeid(-0.9, -1.5, 2.6, 0.0001) ################################
[[-0.9590177847128027, -1.5182413789451041, 2.570965408319012], 4]
#задание8
fn = lambda x: np.e**(x/3) #аналитически найденные фцнкции 
dif = lambda x: (1/3)*np.e**(x/3)
dif2 = lambda x: (1/9)*np.e**(x/3)
a = 0.5; b = 1.5; m = 0.63
rdif = lambda x, d: (fn(x + d) - fn(x))/d 
ldif = lambda x, d: (fn(x) - fn(x - d))/d
ddif = lambda x, d: (fn(x - 2*d) - 8*fn(x - d) + 8*fn(x + d) - fn(x + 2*d))/(12*d)
diff = lambda x, d: (fn(x + d) - fn(x - d))/(2*d)
print(dif(m), '=', rdif(m,0.630000001), '=', ldif(m, 0.6300000002), '=', ddif(m, 0.6300000000001), '=', diff(m, 0.63000003))
#аналитическое, #численные 
0.41122601998558106 = 0.457592850335902 = 0.3709175554749624 = 0.4111992211183748 = 0.41425520316106124
ddiff = lambda x, d: (fn(x - d) - 2*fn(x) + fn(x + d))/d**2;ddiff(m,0.63) 
0.13757983296837314
x = np.linspace(a, b, 50);
xn = np.hstack((x[1:],[10.1]))
f = fn(x); d = dif(x); dd = dif2(x)
dn = rdif(x,xn)
ddn = -ddiff(x,xn)
print(x)
[0.5 0.52040816 0.54081633 0.56122449 0.58163265 0.60204082 0.62244898 0.64285714 0.66326531 0.68367347 0.70408163 0.7244898 0.74489796 0.76530612 0.78571429 0.80612245 0.82653061 0.84693878 0.86734694 0.8877551 0.90816327 0.92857143 0.94897959 0.96938776 0.98979592 1.01020408 1.03061224 1.05102041 1.07142857 1.09183673 1.1122449 1.13265306 1.15306122 1.17346939 1.19387755 1.21428571 1.23469388 1.25510204 1.2755102 1.29591837 1.31632653 1.33673469 1.35714286 1.37755102 1.39795918 1.41836735 1.43877551 1.45918367 1.47959184 1.5 ]
print(xn)
[ 0.52040816 0.54081633 0.56122449 0.58163265 0.60204082 0.62244898 0.64285714 0.66326531 0.68367347 0.70408163 0.7244898 0.74489796 0.76530612 0.78571429 0.80612245 0.82653061 0.84693878 0.86734694 0.8877551 0.90816327 0.92857143 0.94897959 0.96938776 0.98979592 1.01020408 1.03061224 1.05102041 1.07142857 1.09183673 1.1122449 1.13265306 1.15306122 1.17346939 1.19387755 1.21428571 1.23469388 1.25510204 1.2755102 1.29591837 1.31632653 1.33673469 1.35714286 1.37755102 1.39795918 1.41836735 1.43877551 1.45918367 1.47959184 1.5 10.1 ]
import matplotlib.pyplot as plt
plt.figure(figsize=(10,20))
plt.plot(x,f,'ro-',x,d,'r*',x,dd,'gs-',x,d,'y',x,dd, 'b*') 
plt.grid(1)
plt.show()
#задание10
fn = lambda x, u: np.cos(u)/(1.25 + x) - 0.3*u**2
lin = np.linspace(0,1,1000)
x0 = 0;u0 = 0;du0 = fn(0,0)
h = 0.001 
def eulr(x, u):
    y = []
    for i in range(len(lin)):
        u += h*fn(x, u)
        x += h
        y += [u]
    return y
yu = eulr(0,0)
len(lin), len(yu)
(1000, 1000)
plt.plot(lin,yu)
[<matplotlib.lines.Line2D at 0x7f6d7964d860>]
import numpy as np #проверка
from scipy.integrate import odeint
import matplotlib.pyplot as plt


def fun(y, t, a):
    """Define the right-hand side of equation dy/dt = a*y""" 
    f = np.cos(y)/(1.25 + t) - 0.3*y**2
    return f


# Initial condition
y0 = 0

# Times at which the solution is to be computed.
t = np.linspace(0, 1, 51)

# Parameter value to use in `fun`.
a = -2.5

# Solve the equation.
y = odeint(fun, y0, t, args=(a,))

# Plot the solution.  `odeint` is generally used to solve a system
# of equations, so it returns an array with shape (len(t), len(y0)).
# In this case, len(y0) is 1, so y[:,0] gives us the solution.
plt.plot(t, y[:,0])
plt.xlabel('t')
plt.ylabel('y')
plt.show()
##################################################################
fn = lambda x, u: np.cos(u)/(1.25 + x) - 0.3*u**2
lin = np.linspace(0,1,1000)
x0 = 0; u0 = 0; du0 = fn(0,0)
h = 1/len(lin) 
def RulkaKutka(f, x0, y0, x1, n):
    vx = [0] * (n)
    vy = [0] * (n)
    h = (x1 - x0) / float(n)
    vx[0] = x = x0
    vy[0] = y = y0
    for i in range(1, n):
        k1 = h * f(x, y)
        k2 = h * f(x + 0.5 * h, y + 0.5 * k1)
        k3 = h * f(x + 0.5 * h, y + 0.5 * k2)
        k4 = h * f(x + h, y + k3)
        vx[i] = x = x0 + i * h
        vy[i] = y = y + (k1 + k2 + k2 + k3 + k3 + k4) / 6
    return vy
ty = RulkaKutka(fn,0,0,1,1000)
len(lin), len(ty)
(1000, 1000)
plt.plot(lin,ty)
[<matplotlib.lines.Line2D at 0x7f6d7360aac8>]
plt.plot (lin,yu,'r*',lin,ty, 'y')
[<matplotlib.lines.Line2D at 0x7f6d735e2438>, <matplotlib.lines.Line2D at 0x7f6d735e2710>]
#задание 7
import numpy as np
import matplotlib.pyplot as pl
fn = lambda x: 2*x**2+6 / (x**2-2*x+5)
def fun(x):
    return  2*x**2+6 / (x**2-2*x+5)
import numpy as np
import matplotlib.pyplot as plt
n = 5
x = np.linspace(-5, 5, n)
y = fun(x)
def lagranz(x,y,t):
    z = 0
    for j in range(len(y)):
        p1 = 1
        p2 = 1
        for i in range(len(x)):
            if i==j:
                p1 = p1*1
                p2 = p2*1   
            else: 
                p1 *= (t-x[i])
                p2 *= (x[j]-x[i])
        z += y[j]*p1/p2
    return z
xnew=np.linspace(np.min(x),np.max(x),100)
ynew=[lagranz(x,y,i) for i in xnew]
plt.plot(x,y,'o',xnew,ynew)
plt.grid(True)
plt.show()
#################################################################
n = 50
x = np.linspace(-5,5,n)
y = fn(x)

def product( val, n ):
    mul = 1
    for i in range(n):
        if i: mul *= val - x[i-1]
        yield mul
C=[] 
for n in range(len(x)):
    p = product( x[n], n+1 )
    C.append( (y[n]-sum(C[k]*next(p) for k in range(n)) )/next(p) )

def f( v ):
    return sum(C[k]*p for k, p in enumerate(product(v, len(C)) ))
pl.plot(x, fun(x+0.05), '*', x, f(x))
pl.grid(1)
pl.show()
# задание9
import pandas as pd
import numpy as np
from scipy import optimize, linalg
import scipy
from scipy import spatial
import re
import math
import pandas as pd
from numpy import zeros, dot, savetxt
import matplotlib
from matplotlib import pylab as plt
%matplotlib inline
plt.style.use('ggplot')
print(plt.style.available)
['Solarize_Light2', 'seaborn-paper', 'ggplot', 'fivethirtyeight', '_classic_test', 'dark_background', 'seaborn-poster', 'seaborn-deep', 'fast', 'seaborn-dark-palette', 'seaborn-talk', 'seaborn-darkgrid', 'seaborn', 'tableau-colorblind10', 'seaborn-whitegrid', 'seaborn-bright', 'seaborn-muted', 'seaborn-dark', 'seaborn-white', 'classic', 'grayscale', 'seaborn-colorblind', 'seaborn-ticks', 'bmh', 'seaborn-pastel', 'seaborn-notebook']
def Lin_func(vector):
    znach_v = []
    for znach in vector:
        znach_v += [math.sin(znach / 5) * math.exp(znach / 10) + 5 * math.exp(-znach / 2)]
    return znach_v 
def EDin_func(znach):
    return math.sin(znach / 5) * math.exp(znach / 10) + 5 * math.exp(-znach / 2)
a = np.linspace(1, 15, num = 100)
#a, len(a)
#print Lin_func(a),
b = Lin_func(a)
b = [EDin_func(1.), EDin_func(15.)]
b
[3.252216865271419, 0.6352214195786656]
izn3 = [1., 4., 10., 15.]  #
fzn3 = Lin_func(izn3)
izn3 = [1.2, 1.3, 1.4, 1.6, 1.7, 1.9]
fzn3 = [0.6703, 0.5169, 0.4350, 0.2800, 0.2541, 0.2466]
koeff = []
def koeff_search(izn3 = izn3, fzn3 = fzn3):
    work_m = izn3
    znach_func = fzn3
    for i in range(len(work_m)):            #из списка в матрицу
        work_m[i] = [work_m[i]]
    for i in range(len(work_m)):            #умножения количества элементов 
        work_m[i] = work_m[i] * (len(work_m))
    N = 0
    for i in range(len(work_m)):            #создание матрицы квадратов
        for j in range(len(work_m)):
            work_m[i][j] = work_m[i][j] ** N
            N += 1
        N = 0
    koeff = np.linalg.solve(work_m, znach_func) #Находим решение системы
    print(koeff)
    return koeff
def Polin_func1(vector, koeff = koeff):
    znach_f = []
    for znach in vector:
        znach_f += [koeff[0] + ((koeff[1]) * znach) + (koeff[2] * (znach ** 2)) ]
    return znach_f
def Polin_func2(vector, koeff = koeff):
    znach_v = []
    shab = []
    for znach in vector:
        for i in range(len(koeff)):
            shab += [koeff[i] * (znach ** i)]
        znach_v += [float(sum(shab))]
        shab = []
    return znach_v
c =  koeff_search()
[ 409.82909334 -1354.53584685 1787.19101194 -1173.78194447 383.32261906 -49.76587302]
dis = np.linspace(1.2, 1.9, num = 20)
var = Lin_func(dis)
for i in range(len(var)):
    var[i] = (var[i])
x = [1.2, 1.3, 1.4, 1.6, 1.7, 1.9]
y = [0.6703, 0.5169, 0.4350, 0.2800, 0.2541, 0.2466]
plt.plot(x, np.array(y), '*', dis, Polin_func2(dis, koeff=c),'-b')
plt.show
<function matplotlib.pyplot.show(*args, **kw)>
print(abs(np.array(y)) - abs(np.array(Polin_func2(x, koeff=c))))
print(np.sqrt(sum([i - sum(y)/len(y) for i in Polin_func2(x, koeff=c)])/(len(x)*(len(x)-1))));print(4.8348823929e-15)
print(y)
print(Polin_func2(x, koeff=c))
[-1.16573418e-14 3.58602037e-14 1.68254299e-13 4.82058837e-13 -3.35065309e-13 2.83412183e-13] 4.8348823929e-15 [0.6703, 0.5169, 0.435, 0.28, 0.2541, 0.2466] [0.6703000000000117, 0.5168999999999642, 0.43499999999983174, 0.27999999999951797, 0.25410000000033506, 0.2465999999997166]