Contact
CoCalc Logo Icon
StoreFeaturesDocsShareSupport News AboutSign UpSign In
| Download
Project: one
Path: idz.ipynb
Views: 243
Kernel: Python 3 (system-wide)
#задание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__':
Image in a Jupyter notebook
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()
Image in a Jupyter notebook
#задание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>]
Image in a Jupyter notebook
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()
Image in a Jupyter notebook
##################################################################
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>]
Image in a Jupyter notebook
plt.plot (lin,yu,'r*',lin,ty, 'y')
[<matplotlib.lines.Line2D at 0x7f6d735e2438>, <matplotlib.lines.Line2D at 0x7f6d735e2710>]
Image in a Jupyter notebook
#задание 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()
Image in a Jupyter notebook
#################################################################

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()
Image in a Jupyter notebook
# задание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)>
Image in a Jupyter notebook
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]