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 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 principale différence 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 comment cela fonctionne :

• 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 est exécuté à 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écessaires 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 fausse, il existe un risque (par circonstance ou par erreur) que la condition booléenne soit 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 arrêter 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 :

• t : temps (en secondes) ;

• x(t) : position de l'objet à l'instant t ;

• x_i : position initiale de l'objet ;

• v_i : vitesse initiale de l'objet ;

• a : 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 en utilisant des opérations matricielles composantes 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 deux fois une accélération constante 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 à chacune de ces dimensions séparément, et en même temps, on peut considérer cela comme l'analyse d'une dimension unique 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, ainsi que 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 indexation cohérente 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 toujours au-dessus du sol (sa coordonnée z est ≥ 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 en utilisant des opérations matricielles). Le calcul de la position à n'importe quel instant doit dépendre UNIQUEMENT de :

   • La position initiale de l'objet ;

   • La vitesse initiale de l'objet ;

   • Le temps évalué.

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 qui les ont réorganisées en matrices 3D est toujours un bon moyen d'éliminer ces parties du programme comme sources d'erreur ;

• Restreindre la boucle for à une seule itération, ou de manière équivalente, supprimer les objets 2 et 3 (données et étiquettes) du fichier Excel pour voir comment votre programme fonctionne avec un seul objet ;

• Des trajectoires non paraboliques pourraient indiquer un problème dans la façon dont l'équation du mouvement a été appliquée, ou une erreur dans la programmation des calculs composantes par composantes (penser aux points avant les multiplications, etc.) ;

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

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

• Vérifier comment l'accélération a été définie, ou essayer de la fixer à zéro. Cela devrait 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 verrez la même chose) ;

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