Rastell Toull

Site web consacrée à la Bretagne,
à l'Afrique du nord
à la chanson française,
à la recherche scientifique,
et à bien d'autres sujets ...
Le traitement des données statistiques

par Jacques-Deric Rouault

Article original		 Page publique
Page opérationnelle

Version 4.1 du
4 Mai 2012

Table thématique
Table chronologique
Administrateur du site
Comment citer ce document ?
Jacques-Deric Rouault, 2012. Le traitement des données statistiques. Rastell Toull page C123.

Liste des sections développés dans cet article
Section 1
 xls et Scilab
Section 2
 xls et Scilab avec parametres
Section 3
 Scilab et Ada
Section 4
 Scilab et Ada avec passage de données
Section 5
 xls, Scilab et Ada

Présentation

    Pour toute description de méthode, classique ou nouvelle, mathématique et statistique, il est indispensable de fournir un programme qui la met en pratique. Tout d'abord, cela prouve qu'elle est bien implémentable, que tous les ingrédients nécessaires sont bien intégrés et que rien n'a été oublié. Ensuite, cela permet au non-informaticien de la tester sur ses propres données, ce qui est de nature à mieux l'appréhender et à  améliorer sa diffusion.

    On classe les applications informatiques dans deux catégories principales :
    *   La gestion, avec beaucoup de données à traiter, en général dans de gros fichiers, et peu de calculs,
    *   Le calcul scientifique, avec peu de données à traiter, et beaucoup de calculs
    *   A cela vient s'ajouter une troisième catégorie d'applications, relative à la statistique. Autrefois, elle se confondait avec la gestion, mais aujourd'hui, elle brasse beaucoup de données comme la gestion, et necessite beaucoup de calculs basés sur des algorithmes complexes, comme le calcul scientifique.

    Pour traiter des données statistiques, il faut disposer de logiciels aptes à gérer de façon interactive des gros fichiers, effectuer des calculs complexes de façon performante et offrir des sorties graphiques élaborées. Ces contraintes sont relativement contradictoires, et pour réaliser un tel logiciel, il convient de faire appel à un enchainement de plusieurs programmes prenant successivement en charge chaque étape du traitement.

    Dans Rastell-Toull, je vais décrire un certain nombre de méthodes de calcul, de procédures statistiques, d'algorithmes de calcul numérique, et il convient de présenter à chaque fois un programme opérationnel et des jeux d'essai. Qui dit programme dit système d'exploitation et langage de programmation. Et c'est là que les choses se compliquent : à ce jour, il y 3 systèmes d'exploitation majeurs : Windows, Linux/Unix et MacOs X. Il existe des centaines de langages de programmation, et pour ma part, j'en connais une dizaine. Et j'ajoute ici une nouvelle contrainte : les logiciels que j'utilise doivent être gratuits, directement téléchargeables et faciles à mettre en oeuvre !
La solution

    En résumé, je recherche un ensemble de logiciels gratuits, qui marchent sur les 3 systèmes d'exploitation et qui permettent de programmer efficacement les algorithmes les plus complexes. C'est la quadrature du cercle ? Pas tout à fait, et je vous propose la solution que j'ai retenue :

    Pour la gestion des données, le plus pratique est d'utiliser un tableur. Ce sera Calc de la suite gratuite OpenOffice qui est capable de lire et sauvegarder les données au format propriétaire xls de Excel. La version actuelle est la 3.3.0 (FR), et la version 3.4 est en version bêta.

    Pour lire les données, faire des calculs simples, afficher des graphiques, mettre les résultats en fichiers, c'est le logiciel gratuit Scilab qui sait lire les fichiers xls et lancer des exécutables. La version actuelle est la 5.3.3. Il existe des versions précompilées pour Windows 32 et 64 bits, pour Linux 32 et 64 bits, et pour Mac OS X Snow Leopard. La version 5.4.0 est en avant première.

    Pour programmer des algoritmes complexes, c'est ADA, un langage de haut niveau totalement normalisé. Les compilateurs GNAT (Gnu Ada) sont disponibles pour les 3 plateformes. Au niveau performance, ce langage vaut le C, avec en plus des garde-fous extrèmement efficaces. Je détaillerai le téléchargement et l'installation et l'utilisation de Gnat Ada dans une article spécifique.
Premier exemple : Calc et Scilab

    Nous commençons par construire un tableau Calc avec 5 lignes, 2 colonnes et des valeurs, et nous sauvons ce tableau au format xls sous le nom RT_C123A2A1.xls.


    Télécharger le fichier RT_C123A2A1.xls.

    A présent, nous allons construire un programme Scilab qui soit capable de lire ce fichier xls. Pour cela, il existe deux instructions Scilab : xls_open qui ouvre le fichier, et xls_read qui en lit le contenu. Télécharger le programme RT_C123A2A3.sce.


    La fonction xls_open retourne le numéro logique du fichier ouvert fd, une liste de noms SST, une liste de noms de pages Sheetnames et une liste de numéros de pages Sheetpos.

    Dans la fonction xls_read, nous donnons le numero logique du fichier fd et le rang de la page à lire dans le fichier xls Sheetpos(1). Cette fonction retourne un tableau des valeurs numériques Value et un tableau des valeurs non numériques TextInd.

    Le tableau Value contient directement les valeurs numériques contenues dans le tableau xls. Nan se traduit par Not a number et mentionne une valeur non numérique. Le tableau TextInd ne contient les valeurs des chaines de caractères, mais leur rang dans le tableau SST créé à l'ouverture du fichier. Un rang 0 signifie l'absence de chaine.

    Voici ce que donne l'exécution du programme


    Dans ce premier exemple, nous avons créé un fichier xls, et nous en avons lu le contenu depuis un programme Scilab.

Deuxième exemple : Calc et Scilab avec paramètres

    Dans ce deuxième exemple, nous allons utiliser un fichier texte auxilliaire qui va contenir les informations nécessaires au bon déroulement du programme Scilab : le nom du fichier xls à lire, la page à lire, le rang de la colonne et les rangs de début et de fin des lignes à lire. Nous calculerons ensuite la moyenne des valeurs lues.
   Nous commençons par construire un tableau Calc avec 5 lignes, 2 colonnes et des valeurs, et nous sauvons ce tableau au format xls sous le nom RT_C123A3A1.xls.

    Nous définissons maintenanr le fichier texte auxilliaire qui suit une syntaxe bien précise, afin de permettre d'une part à l'utilisateur de préciser exactement les valeurs qu'il souhaite traiter, et d'autre part, d'éviter une confusion toujours impossible de fichiers. Ce fichier est au format Rastell Toull 1.

    Le fichier RT_C123A3A3.txt décrit les parametres de lecture du fichier xls selon un format spécifique.


Le programme RT_C123A3A3.sce se compose de 20 sections. Dans les sections A3 à B15, on  lit le fichier auxilliaire RT_C123A3A3.txt puis dans les sections B16 à B19, on lit le fichier xls désigné et on en extrait les valeurs désignées. Pour la lecture du fichier auxilliaire, se reporter à l'article relatif à la description du format Rastell Toull 1. Pour la lecture du fichier xls, se reporter au premier exemple ci dessus.



Voici la fenetre principale de Scilab où apparaissent les affichages lors d el'exécution du programme.

 
Troisième exemple :  Scilab et Ada

    Nous commençons par écrire un programme Ada très simple. Ce programme RT_C123A4A1.ada affiche le message Connexion établie !. Suit ensuite une boucle de calcul qui permet de maintenir ce message affiché un instant  avant l'éventuelle fermeture automatique de la fenetre d'affichage.


    Voici ce que donne l'exécution de ce programme rt_c123a4a1.exe


    A présent que ce programme Ada est fonctionnel, nous allons le faire exécuter depuis un programme Scilab. En scilab, il existe plusieurs instructions permettant d'éxécuter des commandes du système d'exploitation : dos, unix, unix_g, unix_s, unis_x, unix_w.
    * dos est uniquement réservée à MS-DOS et Windows. Nous ne retiendrons pas ici cette procédure qui permet cependant de faire passer des arguments-parametres.
    * les 4 procédures unix, contrairement à ce que leur nom semble indiquer, fonctionnent à la fois sous MS-DOS (donc Windows) et les différents systèmes Unix, Linux et Mac OS X.

    *   unix : procédure générale
    *   unix_g redirige la sortie vers une variable
    *   unix_w redirige la sorte vers la fenêtre Scilab
    *   unix_x redirige la sortie vers une fenetre

    Nous allons utiliser la procédure unix_w. Le programme Scilab RT_C123A4A4.sce appelle l'exécurable rt_c123a4a1 à l'aide de la porcédure unix_g.


    L'éxécution du programme Scilab donne la sortie suivante : le message gégéralié par la procédure ada est bien affichée dans la fenetre Scilab.

    A l'exécution, on se rend compte qu'il se passe un délai avant l'affichage du message Ada dans la fenetre Scilab.  Nous l'interprétons comme un effet de mémoire tampon.  Le message est envoyé dans une mémoire tampon intermédiaire, qui se vide - donc s'affiche dans la fenetre Scilab - quand elle est pleine, et quand le programme appelé est achevé, qui est le cas ici.
   
Quatrième exemple :  Scilab et Ada avec passage de parametres

    Maintenant, une nouvelle difficulté se pose, si nous voulons échanger des informations (données, résultats, parametres, commentaires)  entre le programme appelant Scilab et le programme appelé Ada. Pour cela nous allons utiliser deux fichiers annexes, le premier à l'appel, le second au retour.

    Selon les besoins, on pourra utiliser des fichiers textes, plus faciles à contrôler mais d'éxécution plus lente, ou des fichiers data typés (entiers ou réels), d'entrée sortie beaucoup plus rapides. Si cela s'avère nécessaire, il pourra à la fois être fait appel à des fichiers texte et data.

    Nous allons développer ici une application Scilab qui envoie les 5 valeurs 1, 12, 25, 8 au programme Ada qui va en calculer la moyenne et la retourner.
Nouc commençons par le programme Ada RT_C123A5A1.ada qui lit le fichier texte RT_C123A5A2.txt, et écrit le fichier texte RT_C123A5A3.txt.



    Le fichier texte RT_C123A5A2.txt contenant les parametres à lire par le programme Ada


    Le fichier texte RT_C123A5A3.txt contenant les parametres retournés par le programme Ada


    Quand on exécute directement le programme rt_c123a5a1.exe, voici la fenetre qu'on obtient :


    A présent, voici le programme Scilab RT-C123A5A4.sce qui va gérérer le fichier texte RT_C123A5A2.txt, appeler l'exécutable rt_c123a5a1.exe, lire le fichier texte RT_C123A5A3.txt, et afficher les résultats du calcul.

 

    Voici la fenetre Scilab après l'exécution du programme. On y trouve les messages du programme Scilab, les message de laporcédure Ada appelée, et les résultats tels que le programme Scilab les a récupérés.
 

Cinquième exemple : Calc, Scilab et Ada

    Dans ce cinquième et dernier exemple, nous intégrons tous les ingrédients qui ont été développés dans les exemples précedents :
    Les données numériques stockées dans le tableau xls RT_C123A6A1.xls
    Le calcul est effectué dans le programme ada RT_C123A6A2.adb et son exécutable rt_c123a6a2.exe
    Le programme Scilab RT_C123A6A5.sce coordonne l'ensemble avec son fichier texte auxilliaire RT_C123A6A5.txt.
    Ce programme Scilab créé le fichier RT_C123A6A3.txt qui est lu par le programme Ada, qui lui-meme créée le fichier RT_C123A6A4.txt qui est lu par le programme Scilab.

    Voici le tableau xls RT_C123A6A1.xls


    Voici le programme ada RT_C123A6A2.adb



    Voici le programme coordonnateur Scilab RT_C123A6A5.sce, dans son intégralité




 
     Voici une première version du fichier texte auxilliaire RT_C123A6A5.txt.


    Quand on lance l'exécution du programme Scilab, voici le fichier texte RT_C123A6A3.txt. La première ligne est un entier qui donne le nombre 5 de valeurs flottantes qui suivent.


   Après l'exécution du programme Ada, les résultats sont retournés dans le fichier RT_C123A6A4.txt

   
    Voici maintenant la fenetre principale Scilab, après exécution du programme


Discussion

    Cette architecture de programmes et de fichiers peut paraitre inutilement complexe. Il vrai, que pour calculer la moyenne de 5 nombres, on n'a pas besoin d'une telle usine à gaz de 7 fichiers, et que cela pouvait être directement réglé en deux coups de cuillère avec un peu de calcul mental.  Vous avez bien compris qu'il s'agit d'un exemple didactique destiné à décrire le cheminement suivi et à en démontrer par l'exemple laparfaite faisabilité.

    Le but de cette architecture est de réaliser simplement, au moins pour l'utilisateur final, des calculs extrèmement complexes, d'une façon relativement simple et économique. Quand nous validerons des modèles théoriques sur la base d'intervalles de confiances calculés à partir de données expérimentales, la question de la complexité apparente ne se posera plus.

    Ici, nous allons montrer toute la puissance de cette architecture, en calculant, non plus la moyenne des 5 valeurs  de la colonne B du tableau xls, mais la moyenne des 4 premières valeurs de la colonne C.  Pour cela, il suffit simplement de modifier en conséquence le contenu du fichier auxilliaire RT_C123A6A5.txt. comme suit : la colonne passe de 2 à 3, la ligne fin de 6 à 5.


    A présent, on relance directement l'exécution du programme Scilab. Voici la fenetre principale :
   

    Avec ce seul petit exemple, on réalise la grande efficacité de cette architecture.

Sources

Open office
http://www.openoffice.org/fr/

Scilab
http://www.scilab.org/fr
http://fr.wikipedia.org/wiki/Scilab

Gnu Ada = GNAT
http://www.gnu.org/software/
http://www.gnu.org/software/gnat/

Liens internes

Autolien
Numéro
 Article
 Auteur
 Rubrique Sous-rubrique Nature
C123
 Le traitement des données statistiques
 Jacques-Deric Rouault B42 Informatique
B46 Proba-Stats
Article original

Cette page utilise les articles
Articles utilisant cette page
Articles connexes
Page d'accueil
Table thématique
Table chronologique
Administrateur du site / Contact