Comparaison de quelques langages de programmation
Sur un exemple concret pris du cours (simulation d'un pendule: intégration du mouvement par un schéma Runge-Kutta d'ordre 4), voici une comparaison de quelques langages de programmation que vous avez à votre disposition. Le problème a été résolu dans chaque langage de trois manières:
- une visant à faire le plus court et plat possible (tout en restant lisible quand même); les versions java et python ont été obtenues à partir du programme C juste en adaptant la syntaxe, ces exemples permettent donc d'apprécier directement les différences de syntaxe élémentaires entre les langages.
- une version avec davantage de modifications cosmétiques, profitant des particularités des langages. L'équation du mouvement est isolée pour n'apparaître plus qu'une fois à un endroit facile à identifier, mais par ailleurs le programme reste le plus 'plat' possible (pas de fichiers externes, pas beaucoup de fonctions). Cette version permet d'apprécier combien des structures particulières des langages permettent de gagner en lisibilité et confort de codage.
- une dernière version a été rédigée librement en utilisant toutes les particularités qui pouvaient être utiles du langage respectif. Le cahier des charges a été rendu plus exigeant au passage, avec l'idée de rendre le programme facile à adapter à d'autres problèmes physiques ou d'autres schémas d'intégration. Le but de cette version était de montrer la manière la plus naturelle de résoudre le problème dans chaque langage avec un maximum de flexibilité et de facilité d'adaptation.
Pour comparer, le mieux est d'ouvrir les programmes dans des nouvelles fenêtres placées côte à côte (un clic droit ou Ctrl-clic sur le lien ouvre un menu qui permet de l'ouvrir dans une nouvelle fenêtre).
Version simple
Cahier des charges
- compact
- simple (structure, syntaxe, ...)
C
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; puis compiler et exécuter:
ordi:~ > gcc -Wall pendule_rk4_mini.c -lm -o pendule_rk4_mini ordi:~ > ./pendule_rk4_mini > pendule.data
Java
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; puis compiler et exécuter:
ordi:~ > javac Pendule_rk4_mini.java ordi:~ > java Pendule_rk4_mini > pendule.data
Noter le peu de différences entre ce programme Java et la version en C.
Python
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; pas besoin de compiler, exécuter avec:
ordi:~ > python pendule_rk4_mini > pendule.data
Noter en particulier: l'absence de déclaration des types de variables, l'absence de point-virgules et d'accolades -- les instructions sont simplement regroupées en blocs selon le nombre d'espaces en début de ligne!
Version intermédiaire
Cahier des charges
- rester compact et plat (un seul fichier, pas trop de fonctions)
- rendre l'équation du mouvement facile à repérer et modifier (en un endroit unique en particulier)
- améliorer si possible la lisibilité
C
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; puis compiler et exécuter:
ordi:~ > gcc -Wall pendule_rk4_moy.c -lm -o pendule_rk4_moy ordi:~ > ./pendule_rk4_moy > pendule.data
Peu de modifications: fonctions pour les équations du mouvement.
Java
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; puis compiler et exécuter:
ordi:~ > javac Pendule_rk4_moy.java ordi:~ > java Pendule_rk4_moy > pendule.data
Nouveauté principale: Définition et utilisation d'une classe Vecteur pour stocker les variables d'état du système.
Python
Code source: ,
Utilisation: Modifier les conditions initiales dans le source, sauvegarder; pas besoin de compiler, exécuter avec:
ordi:~ > python pendule_rk4_moy > pendule.data
Comme dans la version Java, définition d'une classe vecteur pour
stocker l'état du système. La définition elle-même est moins lisible
et évidente que dans le cas du Java, mais nous permet d'étendre
directement les opérateurs arithmétiques *, + aux
vecteurs. Les calculs dans la boucle d'intégration principale
s'écrivent plus naturellement.
Version de luxe
Cahier des charges
- conditions initiales flexibles: au choix soit les prendre en argument (ligne de commande), soit les demander à l'utilisateur, soit les lire dans un fichier
- séparer/rendre plus lisibles les différentes étapes du calcul
- structurer le programme pour
- faciliter la réutilisation pour intégrer un autre système physique (en particulier, les équations du mouvement ne doivent apparaître qu'une seule fois)
- faciliter le passage à un autre schéma d'intégration (p.ex. Euler modifié d'ordre 2)
C
Code source: ,
Utilisation: compiler et exécuter en donnant les conditions initiales comme arguments:
ordi:~ > gcc -Wall pendule_rk4.c -lm -o pendule_rk4 ordi:~ > ./pendule_rk4 theta_init omega_init > pendule.data
Utilisation de tableaux pour l'état du système.
Java
Code source (5 fichiers):
- SimulPendule.java ,
- Pendule.java ,
- RungeKutta4.java ,
- Integrable.java ,
- Integrateur.java ,
Utilisation: télécharger les cinq fichier dans un même répertoire, puis compiler et exécuter en donnant les conditions initiales comme arguments:
ordi:~ > javac SimulPendule.java ordi:~ > java SimulPendule theta_init omega_init > pendule.data
Cette version utilise des notions de programmation orientée objet, afin de montrer comment on peut isoler les différentes parties d'un programme les unes des autres (et les rendre plus indépendantes et réutilisables). SimulPendule ne "voit" pas par exemple comment Pendule stocke les variables d'état. Grâce aux interfaces Integrable et Integrateur, il devient très simple d'écrire d'autre systèmes physiques (Integrable) ou d'autres schémas d'intégration (Integrateur) qui se substitueront parfaitement aux autres dans SimulPendule. L'interface Integrateur représente en quelque sorte un contrat que doit remplir un module pour pouvoir être utilisable là où la simulation a besoin d'un intégrateur. Le module signale qu'il remplit le contrat (c'est-à-dire qu'il dispose des méthodes/fonctions définies dans l'interface) par le 'implements Integrateur' dans la déclaration de la classe. La même chose vaut pour l'interface Integrable.
Python
Code source: ,
Utilisation: inutile de compiler, exécuter avec:
ordi:~ > python pendule_rk4_maxi theta_init omega_init > pendule.data
Rien de nouveau en dehors de l'isolation du schéma Runge Kutta 4 dans une fonction, et de l'initialisation de theta et omega à partir des arguments donnés en ligne de comande. La partie principale du calcul ne pouvait de toute façon plus être beaucoup plus lisible que cela...
Séparer le programme en diverses classes, comme fait pour le Java, serait également possible: Python est également un langage orienté objet.
Autre aspect: visualisation/animation
Pas d'exemples ici (voir cela dit par exemple l'animation Java dans le TD sur le pendule), mais les différences en ce qui concerne l'animation sont grandes. En C, vos options sont essentiellement: communication par pipe avec gnuplot pour l'affichage dynamique de graphiques, ou utilisation d'une bibliothèque graphique comme Cairo. En Java la bibliothèque standard prévoit tout ce qu'il faut, c'est clairement le langage parmi les trois dans lequel des animations sont le plus facile à réaliser, et de manière portable (les programmes Java tournent ensuite indifféremment sur Windows/Mac/Linux/...). Voir la documentation sur Java et les classes maison. Pour le python plusieurs modules sont disponibles et/ou en cours de développement. Une fois installés, l'affichage de graphique devient également relativement facile.