Ici, vous apprendrez à calculer les trajectoires d’objets se déplaçant dans l’espace 3D, ainsi qu’un autre aspect de la programmation : les boucles while, dont les propriétés uniques les rendent tout aussi essentielles que les boucles for et les instructions if, même si elles sont moins fréquemment utilisées.

Structure d’une boucle while

Les boucles while sont similaires aux boucles for, mais leur différence principale réside dans le mécanisme de contrôle de l’itération. Au lieu d’un nombre fixe d’itérations, la boucle while s’exécute tant que la condition booléenne est vraie. Voici son fonctionnement :

• La condition booléenne est évaluée en premier ;

• Si la condition est vraie, le code à l’intérieur de la boucle est exécuté ;

• Après l’exécution du code, la condition est à nouveau vérifiée. Si elle est toujours vraie, le code s’exécute à nouveau. Cela continue tant que la condition reste vraie ;

• Une fois que la condition devient fausse, la boucle se termine et le programme continue à partir du point suivant la boucle.

Cette structure est particulièrement utile lorsque le nombre d’itérations n’est pas connu à l’avance. Elle continue de s’exécuter jusqu’à ce qu’une certaine condition soit remplie, ce qui la rend idéale pour les tâches où le nombre d’itérations dépend de facteurs dynamiques.

Comme les boucles while se répètent tant que la condition booléenne est vraie, il existe un risque (par circonstance ou erreur) que la condition reste toujours vraie et que la boucle while se répète indéfiniment !
Donc, si vous constatez que votre programme prend beaucoup plus de temps que d’habitude, il est conseillé de l’arrêter dans Matlab en appuyant sur :

• Ctrl + C ;

• Cmd + C.

Pour interrompre le code en cours d’exécution et réévaluer la logique et le code.

L’équation du mouvement en 1D avec accélération constante

Dans la vidéo, nous utilisons l’équation du mouvement en 1D :

où :

• $t$ est le temps (en secondes) ;

• $x(t)$ est la position de l’objet à l’instant t ;

• $x_i$ est la position initiale de l’objet ;

• $v_i$ est la vitesse initiale de l’objet ;

• $a$ est l’accélération de l’objet (supposée constante).

Ceci est appliqué indépendamment aux composantes orthogonales x, y, z de la position, de la vitesse et de l’accélération à l’aide d’opérations matricielles composante par composante.

Cette équation est standard en physique et est généralement dérivée algébriquement (un peu plus fastidieux, mais accessible) ou en intégrant une accélération constante deux fois par rapport au temps (et en reconnaissant que les constantes résultantes représentent la vitesse initiale et la position initiale).

Le fait que x, y, z soient orthogonaux (perpendiculaires) permet d’appliquer ceci séparément à chacune de ces dimensions, tout en considérant cela comme une analyse en une seule dimension pour simplifier la compréhension.

Tâche

Écrire votre propre version du programme présenté dans la vidéo en comprenant les objectifs :

1. Importer les positions et vitesses initiales sous forme de matrices distinctes, et les étiquettes des objets sous forme de cell array ;

2. Réorganiser ces données séparément dans deux matrices 3D afin que les positions (coordonnées x, y, z) de chaque objet puissent évoluer le long des colonnes de leur propre couche 2D. On peut faire de même pour les vitesses initiales (même si elles ne changent pas — elles restent toujours les vitesses initiales) pour assurer une cohérence d’indexation par la suite ;

3. Utiliser une boucle for sur les objets afin de calculer la trajectoire 3D de chaque objet ;

4. Calculer la trajectoire de chaque objet à l’intérieur d’une boucle while dont la première condition booléenne vérifie si l’objet est encore au-dessus du sol (sa coordonnée z est $\ge 0$). À l’intérieur de la boucle while, appliquer l’équation du mouvement 1D pour calculer la nouvelle position (appliquer séparément aux coordonnées x, y, z à l’aide d’opérations matricielles). Le calcul de la position à n’importe quel instant doit dépendre UNIQUEMENT :

   • De la position initiale de l’objet ;

   • De la vitesse initiale de l’objet ;

   • Du temps considéré.

Il ne doit pas dépendre de la position précédente calculée.

• Vérifier les données d’entrée (positions et vitesses initiales) ainsi que les variables ayant réorganisé ces données en matrices 3D est toujours une bonne méthode pour éliminer ces parties du programme comme sources potentielles d’erreur ;

• Restreindre la boucle for à une seule itération, ou retirer les objets 2 et 3 (données et étiquettes) du fichier Excel pour observer le comportement du programme avec un seul objet ;

• Des trajectoires non paraboliques peuvent indiquer un problème dans l’application de l’équation du mouvement, ou une erreur dans la programmation des calculs composant par composant (ne pas oublier les points avant les multiplications, etc.) ;

• Les positions initiales (première colonne de chaque couche 2D) de votre matrice de trajectoire 3D doivent correspondre à celles enregistrées dans le fichier Excel ;

• Il ne devrait pas y avoir de valeurs négatives (chaque objet commence avec une position et une vitesse positives dans toutes les directions x, y, z) ;

• Vérifier la définition de l’accélération, ou essayer de la fixer à zéro. Cela doit produire un mouvement à vitesse constante, qui doit former des lignes lors de la représentation graphique (si vous prenez la vue de dessus du graphique 3D, qui ne montre que le mouvement dans les directions x, y où l’accélération était nulle, vous observerez le même résultat) ;

• Selon notre système de coordonnées, la gravité est $-9.8 m/s^2$ (vers le bas, en direction de la Terre), et non $+9.8$.