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]