Exercice type 11 - 2014

# -*- coding: utf-8 -*-
# Katia Barré - Lycée Lesage Vannes

import numpy as np
import
matplotlib.pyplot as plt
import
scipy.integrate as integ

b, w = 0.5, 6.0

#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')

def p(t):
   
global b, w
    wt
= w * t
   
return np.cos(t) + b * np.cos(wt), np.sin(t) + b * np.sin(wt)

def v(t):
   
global b, w
    wt
= w * t
    bw
= b * w
   
return -np.sin(t) - bw * np.sin(wt), np.cos(t) + bw * np.cos(wt)

def a(t):
   
global b, w
    wt
= w * t
    bw2
= b * w**2
   
return -np.cos(t) - bw2 * np.cos(wt), -np.sin(t) - bw2 * np.sin(wt)

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

dt = np.pi * 0.01
t
= np.arange(-np.pi, np.pi + dt, dt)
pt
= p(t)

plt.figure(1)
plt
.plot(pt[0], pt[1])
plt
.xlabel('$x(t)$')
plt
.ylabel('$y(t)$')
plt
.title('Trajectoire')
plt
.grid()
plt
.axis('scaled')

plt.show()

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')

def c(t):
    x
, y = p(t)
    x1
, y1 = v(t)
    x2
, y2 = a(t)

    d = (x1**2 + y1**2) / (x1 * y2 - y1 * x2)
    return x - d * y1, y + d * x1

ct = c(t)

plt.figure(2)
plt
.plot(pt[0], pt[1])
plt
.plot(ct[0], ct[1])


#--- tracé de quelques segments [p(t)c(t)]

for
u in np.linspace(-np.pi + dt, -dt, 5):
    xp
, yp = p(u)
    xc
, yc = c(u)
    plt
.plot([xp, xc], [yp, yc], marker = 'o', color = 'r')

plt.grid()
plt
.legend(['Point $p$', 'Centre de courbure $c$'])
plt
.title('Trajectoire et développée')
plt
.axis('scaled')

plt.show()

#--- question 6 ----------------------------------------------------------------
print
('\n --- Question 6 --- ')

def distance(A, B):
   
"""

    A et B : deux points du plan (couples de float)
    retourne la longueur du segment [AB]

   
"""
    xA
, yA = A
    xB
, yB = B
   
return ((xB - xA)**2 + (yB - yA)**2)**0.5

def longueur(N):
   
"""

    N : entier naturel > 0
    Renvoie la longueur de la ligne polygonale reliant les points p(t)
        pour t dans [-pi, pi] pour le pas de discrétisation delta_t = pi / N

   
"""
    t
= np.linspace(-np.pi, np.pi, 2 * N)
    long
= 0
    A
= p(t[0])
   
for i in range(1, 2 * N):
        B
= p(t[i])
        long
+= distance(A, B)
       
A = B
   
return long

longueur_v = np.vectorize(longueur)

#---------- tracé de la longueur de la ligne polyngonale en fonction du nombre de points

n = range(20, 301, 3)
long_n
= longueur_v(n)

plt.plot(n, long_n, linestyle = 'None', marker = 'o', ms = 3)
norme_v
= lambda u : (1 + (b * w)**2 + 2 * b * w * np.cos((w-1) * u))**0.5
longueur_p
, err = integ.quad(norme_v, -np.pi, np.pi)
plt
.plot([20, 300], [longueur_p, longueur_p], color = 'r')
plt
.xlabel('$N$')
plt
.ylabel('Longueur en fonction de $N$')
plt
.legend(['Longueur du polygône avec $2N$ points', 'Longueur de la courbe'],\ loc = 'lower right')
plt
.grid()
plt
.show()

 

--- Question 1 ---

--- Question 2 ---

 --- Question 3 ---

--- Question 4 ---

--- Question 5 ---

 

 --- Question 6 ---

 

Exercice type 10 - 2014

# -*- coding: utf-8 -*-
# Katia Barré  - Lycée Lesage Vannes

import random

#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')

def comptage(L, N):
   
"""

    N : entier > 10
    L : liste d'entiers de [0, N - 1]
    Renvoie une liste P telle que P[k] est le nombre d'occurence de k dans L

   
"""
    P = [0] * N
   
for x in L:
        P
[x] += 1
   
return P

N = 5
mL
= [random.randint(0, N - 1) for i in range(20)]
print
('Liste L = ', mL)
print
('Comptage(L, 5) = ', comptage(mL, N))

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

def tri(L, N):
   
"""

    N : entier
    L : liste d'entiers de [0, N - 1]
    Renvoie la liste L triée par ordre croissant

    """

    P
= comptage(L, N)
    Q
= []
   
for i in range(N):
       
for k in range(P[i]):
            Q
.append(i)
   
return Q

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

print
('        L = ', mL)
print
('tri(L, 5) = ', tri(mL, N))

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')
print
('En notant M = len(L),')
print
('La fonction comptage est de complexité O(M + N), de même que la fonction tri.')
print
('Le tri par insertion est de complexité O(N^2).')

print('Le tri par fusion est de complexité O(N ln(N)).')

 

--- Question 1 ---

Liste L =  [0, 0, 4, 0, 4, 0, 3, 3, 1, 1, 2, 4, 3, 1, 3, 4, 0, 1, 3, 3]
Comptage(L, 5) =  [5, 4, 1, 6, 4]

 --- Question 2 ---

 --- Question 3 ---

        L =  [0, 0, 4, 0, 4, 0, 3, 3, 1, 1, 2, 4, 3, 1, 3, 4, 0, 1, 3, 3]
tri(L, 5) =  [0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4]

 --- Question 4 ---

En notant M = len(L),
La fonction comptage est de complexité O(M + N), de même que la fonction tri.
Le tri par insertion est de complexité O(N^2).
Le tri par fusion est de complexité O(N ln(N)).

Exercice type 9 - 2014

# -*- coding: utf-8 -*-
# Katia Barré  - Lycée Lesage Vannes

import numpy as np
#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')

R = np.arange(1, 7).reshape(2, 3)
print
('R = \n', R)
S
= np.arange(1, 10).reshape(3, 3)
print
('S = \n', S)

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

def test(M):
   
"""

    M : matrice
    Renvoie n si M est carrée d'ordre n

           
0 sinon
    """

    n
= len(M)
   
if n == len(M[0]):
       
return n
   
else:
       
return 0

print('test(R) = ', test(R))
print
('test(S) = ', test(S))

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

fichier = open('data/ex_009.txt', 'r')
matrice
= []
for
ligne in fichier
    matrice.append(list(eval(ligne)))
fichier
.close()

M1 = np.array(matrice)
print
('M1 = \n', M1)
print
('test(M1) = ', test(M1))

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')

print('La matrice est symétrique réelle donc toutes ses valeurs propres sont réelles.')
valp_M1
, vecp_M1 = np.linalg.eig(M1)
print
('Valeurs propres de M1 : \n ', valp_M1)

#--- question 5 ----------------------------------------------------------------
print
('\n --- Question 5 --- ')

def dansIntervalle(L, a, b):
   
"""

    L : liste de nombres complexes
    a, b : float
    Renvoie True si tous les éléments de L sont dans [a, b]

           
False sinon
    """

   
for x in L:
       
if abs(x.imag) > 1e-16 or x.real > b or x.real < a:
           
return False
   
return True

print('dansIntervalle(valp_M1, 0, 1) = ', dansIntervalle(valp_M1, 0, 1))

 

--- Question 1 ---
R =
[[1 2 3]
[4 5 6]]

S =
[[1 2 3]
[4 5 6]
[7 8 9]]

 --- Question 2 ---

test(R) =  0
test(S) =  3

 --- Question 3 ---
M1 =
[[ 0.33333333  0.16666667  0.16666667  0.16666667  0.16666667]
[ 0.16666667  0.33333333  0.16666667  0.16666667  0.16666667]
[ 0.16666667  0.16666667  0.33333333  0.16666667  0.16666667]
[ 0.16666667  0.16666667  0.16666667  0.33333333  0.16666667]
[ 0.16666667  0.16666667  0.16666667  0.16666667  0.33333333]]
test(M1) =  5

--- Question 4 ---
La matrice est symétrique réelle donc toutes ses valeurs propres sont réelles.
Valeurs propres de M1 :
  [ 1.          0.16666666  0.16666667  0.16666667  0.16666667]

 --- Question 5 ---
dansIntervalle(valp_M1, 0, 1) =  True

Exercice type 8 - 2014

# -*- coding: utf-8 -*-
# Katia Barré - Lycée Lesage Vannes


import
numpy as np
import
matplotlib.pyplot as plt

M, m = 20, 10

#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')

def f(c):
   
"""

    c : nombre
    On considère la suite récurrente définie par :
        u_0 = 0 et u_{n+1} = u_n **2 + c pour tout entier naturel n

    Renvoie : le plus petit entier k de [0, m] tel que |u_k| > M s'il existe
              m + 1 sinon

    """

   
global M, m
    u
= 0
   
k = 0
   
while k < m:
        u
= u**2 + c
        k
+= 1
       
if abs(u) > M:
           
return k      # renvoie k de [0, m] tel | u_k| > M
   
return m + 1          # renvoie m + 1

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

f_v = np.vectorize(f)
LX
= np.linspace(-2, 2, 401)
fX
= f_v(LX)

plt.figure(1)
plt
.plot(LX, fX, linestyle = 'None', marker = '.', ms = 3)
plt
.axis([-2.1, 2.1, -0.1, m + 1.1])
plt
.grid()
plt
.xlabel('$c$')
plt
.ylabel('$f(c)$')
plt
.title('Graphe de $f$')
plt
.show()

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

K = 101
x
= np.linspace(-2, 0.5, K)
y
= np.linspace(-1.1, 1.1, K)
X
, Y = np.meshgrid(x, y)
tableau_valeurs
= f_v(X + 1j * Y)

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')

plt.figure(2)
plt
.imshow(tableau_valeurs, extent = [-2, 0.5,-1.1 ,1.1])
plt
.title('$M = $ {}, $m$ = {}, $K$ = {}'.format(M, m, K))
plt
.axis('scaled')
plt
.show()

print('Pour augmenter la résolution, on peut augmenter les paramètres M, m et K.')

#--- tests ---------------------------------------------------------------------
def
f1(c, m, M):
        u
= 0
        k
= 0
       
while k < m:
            u
= u**2 + c
            k
+= 1
           
if abs(u) > M:
               
return k
       
return m + 1

f1_v = np.vectorize(f1)

def resolution(m, M, K):
   
"""

    m : entier limite l'indice de la suite
    M : limite le module de la suite
    K : nombre de points sur les axes
    Trace l'image du code du tableau f(x + jy)
     où x dans [-2, 0.5] (K valeurs)
        y dans [-1.1, 1.1] (Ka valeurs)
        f fonction qui à un nombre complexe c
            associe le plus petit entier k de [0, m] tel que |u_k| > M s'il existe
                    m + 1 sinon
            avec (u_n) la suite récurrente définie par :
               u_0 = 0 et u_{n+1} = u_n **2 + c pour tout entier naturel n

    """

    x
= np.linspace(-2, 0.5, K)
    y
= np.linspace(-1.1, 1.1, K)
    X
, Y = np.meshgrid(x, y)
    tableau_valeurs
= f1_v(X + 1j * Y, m, M)


    plt
.imshow(tableau_valeurs, extent = [-2, 0.5,-1.1 ,1.1])
    plt
.title('$M = $ {}, $m$ = {}, $K$ = {}'.format(M, m, K))
   
plt.axis('scaled')
    plt
.show()

resolution(20, 30, 200)

resolution(30,50, 500)

 

--- Question 1 ---

--- Question 2 ---


--- Question 3 ---

--- Question 4 ---

Pour augmenter la résolution, on peut augmenter les paramètres M, m et K.

 

Search