Utilisation de la libraire graphique Dislin

Utilisation de la librairie graphique Dislin

Télécharger et installer Dislin

La librairie graphique Dislin est une librairie logicielle développée et distribuée par le Max Planck Institute for Solar System Research, un institut de recherche universitaire allemand. Ce soft est sous licence GNU.
Pour télécharger la librairie , il suffit d'aller sur le site du Max Planck Institut et de cliquer sur le nom du fichier qui va bien, soit dl_95_mg.zip pour nos environnements de développement Dev C++ et VFort, qui utilisent les compilateurs GCC et G77 respectivement. La version courante en octobre 2009 est la version 9.5.
Pour installer Dislin sur votre PC sous Windows (2000, XP ou Vista - je n'ai pas essayé sous 98 ou Windows 7):

Décompresser le fichier dl_95_mg.zip dans un répertoire temporaire quelconque,
Aller dans ce répertoire et double-cliquer sur setup, le programme d'installation. Celui-ci vous propose de créer le répertoire C:/Dislin">C acceptez, c'est plus simple pour tout le monde.
Copier le fichier C:\dislin\dislin.h dans votre répertoire Dev-Cpp\include
Copier le fichier C:\dislin\real64\dislin_d.h dans votre répertoire Dev-Cpp\include
Copier les fichiers C:\dislin\dismg.a et C:\dislin\dismg_d.a dans votre répertoire Dev-Cpp\lib
Dans Dev-Cpp\lib, renommer dismg.a en libdismg.a et dismg_d.a en libdismg_d.a

Voilà, l'installation est terminée...
Le site du Max Planck Institue propose une documentation en ligne (On Line Manual). Vous trouverez ici une version pdf de la documentation de la version 9.5 très bien faite.
Une précision importante : le fichier header dislin.h et le fichier librairie libdismg.a sont à utiliser avec des variables de type float. Le fichier header dislin_d.h et le fichier librairie libdismg_d.a sont à utiliser avec des variables de type double. Toute erreur dans le choix des bons fichiers est sanctionnée par des erreurs de compilation parfois étranges....

Dislin en C/C++ avec DevCpp

Vous avez constaté parmi nos pages que le besoin de tracer des courbes est très pressant! On n'imagine pas un programme de physique numérique sans courbe 2D ou 3D! Jusqu'à présent, dans mes programmes diffusés sur TangenteX.com, j'utilisais Gnuplot pour tracer des courbes à partir de données stockées dans des fichiers. Gnuplot est un très bon outil, mais les courbes obtenues l'étaient après les calculs...
J'ai fait un petit détour par dislin, sous FORTRAN, dans le programme PaquetOndes à l'occasion de l'étude de l'équation de Schrödinger. Et j'ai trouvé cette librairie intéressante. Aussi, j'ai essayé de l'utiliser sous Dev-C++.
Voici un programme de simulation de marche aléatoire 2D sur un domaine [0,1][0,1], qui n'est pas parfait mais qui donne une idée:

//*****************************************************************************

// Simulation d'une marche aléatoire 2D

// Dominique Lefebvre - Octobre 2009 V1.0

// TangenteX

// www.tangenteX.com

//******************************************************************************

#include <cstdlib>

#include <iostream>

#include <dislin_d.h>

#include <math.h>

#include <time.h>

using namespace std;

// déclaration des constantes

#define NBPAS 1000

#define X 0

#define Y 1

#define PI 3.141592654

// déclaration des variables globales

long seed;

//******************************************************************************

// Génération de nombres aléatoires distribués uniformément entre 0 et 1

// Selon la formule de Lehmer et l'algorithme et les paramètres de

// Parker and Miller (1988):

// x(i+1) = a*x(i) mod c

// Sa période est fixée par c, soit 2^31 - 1

//******************************************************************************

double Random(void)

{

const double a = 16807.0; // 7^5

const double c = 2147483647.0; // 2^31 - 1

double x,y;

x = a*seed;

seed = (long)(fmod(x,c));

y = seed/c; // normalisation par c

return (y);

}

//******************************************************************************

// Génération de la constante d'initialisation du générateur Random

// à partir de la date courante selon Anderson (1990)

//******************************************************************************

long GenerationSeed(void)

{

struct tm *temps;

time_t maintenant;

int t0,t1,t2,t3,t4,t5;

long lseed;

// récupération de l'heure actuelle

time(&maintenant);

// enregistrement de l'heure actuelle

temps = localtime(&maintenant);

// conversion en structure tm

t0 = temps->tm_sec;

t1 = temps->tm_min;

t2 = temps->tm_hour;

t3 = temps->tm_mday;

t4 = temps->tm_mon;

t5 = temps->tm_year;

// calcul du seed d'après l'algo d'Anderson (seed varie entre 0 et 2^31-1

lseed = t5 + 70*(t4 + 12*(t3 + 31*(t2 + 23*(t1 + 59*t0))));

// s'assurer que seed est impair

if ((lseed%2) == 0) lseed = lseed-1;

return lseed;

}

//******************************************************************************

// Programme principal

//******************************************************************************

int main(int argc, char *argv[])

{

FILE *Donnees;

char Buffer[20];

int i,ipoint;

double Points[NBPAS][2];

// Table de coordonnées des points

double d, alpha, x , y;

// initialisation du générateur

printf("Simulation d'une marche aleatoire 2D" " - Dominique Lefebvre Octobre 2009\n\n");

seed = GenerationSeed();

// initialisation de l'affichage graphique (lib dislin)

metafl("XWIN");

disini();

pagera();

pagfll(255);

color("black");

hwfont();

titlin("Marche aleatoire 2D",1);

graf(0.0,1.0,0.0,0.1,0.0,1.0,0.0,0.1);

title();

// initialisation du mouvement

color("red");

ipoint = 0;

Points[ipoint][X] = 0.5;

Points[ipoint][Y] = 0.5;

rlstrt(Points[ipoint][X],Points[ipoint][Y]); // plot à l'origine du mouvement

// boucle de calcul des points de la marche

for(ipoint=1;ipoint;ipoint++)

{

// calcul de la distance du déplacement

d = Random()/10.0;

// calcul de l'angle de déplacement en radian

alpha = 2*PI*Random();

// calcul des coordonnées du prochaine point

x = Points[ipoint-1][X] + d*cos(alpha);

y = Points[ipoint-1][Y] + d*sin(alpha);

// normalisation aux frontières du domaine

if (x > 1.0) x = 1.0;

if (y > 1.0) y = 1.0;

if (x < 0.0) x = 0.0;

if (y < 0.0) y = 0.0; // enregistrement des coordonnées

Points[ipoint][X] = x;

Points[ipoint][Y] = y;

rlconn(Points[ipoint][X],Points[ipoint][Y]); // plot le point

}

// Fin du programme

disfin();

return EXIT_SUCCESS;

Le source du programme est disponible ici. Pour compiler et linker le programme avec dslin, notez les points suivants:

Ne pas oublier la déclaration #include <dislin_d> , car j'utilise des doubles. En cas d'utilisation de float, inclure dislin.h . Attention, en C++, cette inclusion doit être faite après l'inclusion de <iostream.h>.
Aller dans Project/Project Options/Parameters/Linker et ajouter les commandes -ldismg_d -lgdi32 Attention: si vous utilisez des float, il faut ajouter -ldismg

Ce faisant, la compilation et le link devraient se passer sans problème! Si il y a un problème, revoir votre installation ou/et le type de variables utilisées.

Je vous laisse découvrir la puissance de dislin à travers ce programme et la doc de dislin... En cas de question, mon forum

Dislin en Fortran avec VFort

Je vous laisse retourner voir le code du programme PaquetOndes, et plus particulièrement la routine TraceCourbe. Vous y retrouverez les mêmes appels, ce qui fait qu'il est très facile de passer d'un langage à l'autre en utilisant Dislin.
Pour compiler et linker le code sans problème, allez dans Project\Project Options et dans le champ Additional libraries tapez -ldislin -luser32 -lgdi32 -lcomdlg32
Comme en C, attention à bien utiliser la bonne librairie (32 ou 64 bits).