Exo Type 11- 2014

 

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 ---

 

Search