Exercices sur les tuples en Python 3

Points et vecteurs dans le plan

On décide de représenter un point ou un vecteur du plan par le tuple de ses coordonnées cartésiennes (x, y), toutes deux flottantes.

Écrire le prédicat float_is_close (x1, x2, epsilon= EPSILON) qui teste si deux flottants sont proches, c'est-à-dire à une distance inférieure à epsilon près. En déduire le prédicat vector_equals (vector1, vector2, epsilon= EPSILON) testant si deux vecteurs sont à peu près égaux, c'est-à-dire si leurs coordonées cartésiennes sont proches.
```
EPSILON= 0.000000001
def float_is_close (x1, x2, epsilon= EPSILON):
    pass

def vector_equals (vector1, vector2, epsilon= EPSILON):
    pass

assert     vector_equals ( (3.1000000000001, 5.2), (3.1, 5.2000000000001) )
assert not vector_equals ( (3.1000001,       5.2), (3.1, 5.2000001      ) )
```
Écrire une fonction vector_rotated_by_90 (vector) qui retourne le vecteur vector après rotation de 90 degrés dans le sens trigonométrique.
```
def vector_rotated_by_90 (vector):
    pass

assert vector_equals (vector_rotated_by_90 ((0.25, 0.75)), (-0.75, 0.25))
```

Écrire une fonction point_translated_by (point, vector) qui retourne le translaté d'un point par un vecteur.

def point_translated_by (point, vector):
    pass

assert vector_equals ((11, 22), point_translated_by ((10, 20), (1, 2)))

Écrire une fonction vector_between (start, end) qui retourne le vecteur allant du point start au point end.

def vector_between (start, end):
    pass

assert vector_equals ((8, 5), vector_between ((2, 4), (10, 9)))

Écrire une fonction point_middle_of (point1, point2) qui retourne le milieu de deux points.

def point_middle_of (point1, point2):
    pass

assert vector_equals ((2.5, 8), point_middle_of ((2, 7), (3, 9)))

Écrire une fonction vector_from_polar (rho, theta) qui retourne le vecteur de longueur rho et d'angle theta.

def vector_from_polar (rho, theta):
    pass

assert vector_equals (( 0, 3), vector_from_polar (3, math.pi/2))
assert vector_equals ((-3, 0), vector_from_polar (3, math.pi))

Écrire une fonction vector_length (vector) qui retourne la longueur d'un vecteur.

def vector_length (vector):
    pass

assert float_is_close (7, vector_length (vector_from_polar (7, 1.5)))

Écrire une fonction vector_scaled_by (vector, alpha) qui retourne le produit d'un vecteur par un scalaire.

def vector_scaled_by (vector, alpha):
    pass

assert vector_equals ((8, 10), vector_scaled_by ((4, 5), 2))

Écrire une fonction vector_resized_to (vector, size) qui retourne le vecteur de longueur size et de même direction que vector. Si le vecteur est trop proche du vecteur nul, on choisit arbirairement de retourner le vecteur horizontal (size, 0).
```
def vector_resized_to (vector, size):
    pass

assert vector_equals (vector_from_polar (3, 1.5), 
                      vector_resized_to (vector_from_polar (7, 1.5), 3))
```