Valid XHTML     Valid CSS2    

Listing du fichier tutrprog.php

 

00001     <?php
00002     #   # (gH)   -_-  index.php  ;  TimeStamp (unix) : 02 Janvier 2015 vers 18:12
00003     error_reporting
(E_ALL E_NOTICE ) ;
00004     include("../../std7.php"
) ;
00005     include("progi.php"
) ;
00006     $titre 
"Introduction &agrave; la programmation avec R" ;
00007     debutPage
($titre,"strict") ;
00008     debutSection
() ;
00009     h1
($titre) ;
00010     h2
(s_nbsp(16).s_span('gilles.hunault "at" univ-angers.fr',"gvert")) ;
00011     
00012     #######################################################################################################################
00013     
00014     pvide
() ;
00015     $nbp 
;
00016     h1
("Ce tuteur se compose de $nbp parties :") ;
00017     pvide
() ;
00018     
00019     blockquote
() ;
00020     for ($ipartie
=1;$ipartie<=$nbp;$ipartie++) {
00021       h3
("Partie $ipartie : ".ghBleu(seances($ipartie))) ;
00022     } ; # fin pour ipartie
00023     finblockquote
() ;
00024     pvide
() ;
00025     
00026     #######################################################################################################################
00027     
00028     $numcours 
partie($numcours) ; pvide() ;
00029     $rubrique  
;
00030     $rubriques1 
= array() ;
00031     $rubrique
++ ; $rubriques1[$rubrique] = "Qu'est-ce que la programmation en R&nbsp;?" ;
00032     $rubrique
++ ; $rubriques1[$rubrique] = "Comment apprendre &agrave; programmer&nbsp;?" ;
00033     $rubrique
++ ; $rubriques1[$rubrique] = "Pr&eacute;sentation des cours" ;
00034     $rubrique
++ ; $rubriques1[$rubrique] = "Principes de programmation" ;
00035     $rubrique
++ ; $rubriques1[$rubrique] = "Sp&eacute;cificit&eacute;s du langage $R;
00036     
00037     $tdmCRLM1 
= new tdm($rubriques1) ;
00038     $tdmCRLM1
->titre() ;
00039     $tdmCRLM1
->menu("oui","oui","nou","p$numcours") ;
00040     
00041     $numRub 
;
00042     
00043     #######################################################################################################################
00044     #
00045     # progic1
00046     #
00047     #######################################################################################################################
00048     
00049     $tdmCRLM1
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Qu'est-ce que la programmation en R ?
00050     
00051     ## -------------------------------------------------------------------------------------------
00052     
00053     blockquote
() ;
00054     
00055     p
("texte") ;
00056     echo "Programmer, c'est, "
.bleu("historiquement")." &laquo;".b(vert("&eacute;crire"))."&raquo; des programmes, " ;
00057     echo " c'est-&agrave;-dire des textes dans un langage sp&eacute;cial compris par un ordinateur. " 
;
00058     echo " Ecrire est mis ici pour "
.b("r&eacute;aliser").", ce qui signifie &agrave; la fois concevoir, &eacute;crire, tester, documenter. " ;
00059     echo " Lorsqu'un programme est d'importance (penser &agrave; un programme qui g&egrave;re le d&eacute;collage des avions dans un a&eacute;roport), " 
;
00060     echo " plusieurs personnes voire plusieurs centaines de personnes peuvent y participer. " 
;
00061     finp
() ;
00062     
00063     p
("texte") ;
00064     echo "L'expression "
.em("langage sp&eacute;cial")." indique qu'il va falloir en quelque sorte apprendre une nouvelle langue, " ;
00065     echo " simplifi&eacute;e (bas&eacute;e plus ou moins sur l'anglais) et surtout, qu'il va falloir "
.em(vert("tout dire en utilisant cette langue")).". " ;
00066     echo " On utilise parfois un autre langage moins sp&eacute;cifique nomm&eacute; "
.rouge("algorithmique")." en fran&ccedil;ais pour juste " ;
00067     echo " r&eacute;fl&eacute;chir aux id&eacute;es, aux concepts et aux actions &agrave; ex&eacute;cuter." 
;
00068     finp
() ;
00069     
00070     p
("texte") ;
00071     echo "Dans un langage de programmation, on trouve en g&eacute;n&eacute;ral cinq actions principales&nbsp;" 
;
00072     finp
() ;
00073     
00074     ul
() ;
00075     
00076      debutli
() ; p() ;
00077        echo bleu
("effectuer")." un calcul (plus ou moins complexe)" ;
00078      finp
() ; finli() ;
00079     
00080      debutli
() ; p() ;
00081        echo bleu
("lire")." une ou plusieurs valeurs (au clavier, dans un fichier, en m&eacute;moire...)" ;
00082      finp
() ; finli() ;
00083     
00084      debutli
() ; p() ;
00085        echo bleu
("&eacute;crire")." une ou plusieurs valeurs (&agrave; l'&eacute;cran, dans un fichier, en m&eacute;moire...)" ;
00086      finp
() ; finli() ;
00087     
00088      debutli
() ; p() ;
00089        echo bleu
("appeler")." un sous-programme (avec &eacute;ventuellement des param&egrave;tres)" ;
00090      finp
() ; finli() ;
00091     
00092      debutli
() ; p() ;
00093        echo bleu
("g&eacute;rer")." le flux des instructions (faire des tests ou des boucles)" ;
00094      finp
() ; finli() ;
00095     
00096     finul
() ;
00097     
00098     
00099     p
("texte") ;
00100     echo "La programmation en R est un peu "
.b("sp&eacute;ciale")." dans la mesure o&ugrave; on n'&eacute;crit pas vraiment des " ;
00101     echo " programmes mais plut&ocirc;t des "
.rouge("scripts")." dans un environnement. " ;
00102     echo " Nous reviendrons r&eacute;guli&egrave;rement sur cette diff&eacute;rence au travers d'exemples " 
;
00103     echo " afin que vous puissiez aussi programmer dans d'autres langages. " 
;
00104     finp
() ;
00105     
00106     finblockquote
() ;
00107     
00108     #######################################################################################################################
00109     
00110     $tdmCRLM1
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Comment apprendre &agrave; programmer ?
00111     
00112     ## -------------------------------------------------------------------------------------------
00113     
00114     blockquote
() ;
00115     
00116     p
("texte") ;
00117     echo "Pour apprendre &agrave; programmer, il faut donc utiliser les m&ecirc;mes techniques que pour " 
;
00118     echo " apprendre une nouvelle langue. Cela inclut donc beaucoup de pratique, de r&eacute;p&eacute;tition, d'entrainement." 
;
00119     echo " Apr&egrave;s avoir maitris&eacute; le "
.b("vocabulaire de base").", on passe &agrave; la ".b("syntaxe")." &eacute;l&eacute;mentaire puis " ;
00120     echo " au bout d'un certain temps on passe &agrave; des phrases plus longues, on apprend la "
.b("grammaire")." et surtout, " ;
00121     echo " on continue encore et encore..." 
;
00122     finp
() ;
00123     
00124     p
("texte") ;
00125     echo "L'avantage avec l'ordinateur, c'est qu'il est "
.bleu("infiniment patient")." et qu'on ne risque pas de l'&eacute;nerver en commettant toujours " ;
00126     echo " la m&ecirc;me erreur, qu'on peut essayer et essayer encore et encore, jusqu'&agrave; temps qu'on arrive &agrave; se faire " 
;
00127     echo " comprendre. Par contre, le gros d&eacute;faut, c'est qu'il est "
.b("b&ecirc;te")." ou plus exactement " ;
00128     echo b
("m&eacute;canique")." et qu'il est incapable d'accepter l'".rouge("&agrave; peu pr&egrave;s").". " ;
00129     finp
() ;
00130     
00131     p
("texte") ;
00132     echo "Par exemple si un &eacute;tranger vous dit " 
;
00133     echo "&laquo;"
.em(vert("je voudrais un papier blanche"))."&raquo;" ;
00134     echo " ou " 
;
00135     echo "&laquo;"
.em(vert("je voudrais une blanche papier"))."&raquo;" ;
00136     echo " vous corrigerez de vous-m&ecirc;mes en "
.b("papier blanc")." et vous comprendrez ce que veut la personne." ;
00137     echo " Si par contre vous demandez &agrave; l'ordinateur d'appeler le sous-programme " 
;
00138     echo em
(vert("CALCUL(x,)y")) ;
00139     echo " au lieu du sous-programme " 
;
00140     echo em
(vert("CALCUL(x,y)")) ;
00141     echo ", il ne saura que vous r&eacute;pondre " 
;
00142     echo bleu
("\"erreur de syntaxe, \"") ;
00143     echo " et  peut-&ecirc;tre, dans le meilleur des cas, " 
;
00144     echo bleu
("\"variable manquante apr&egrave;s la virgule\"").". " ;
00145     finp
() ;
00146     
00147     finblockquote
() ;
00148     
00149     #######################################################################################################################
00150     
00151     $tdmCRLM1
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Pr&eacute;sentation des cours
00152     
00153     ## -------------------------------------------------------------------------------------------
00154     
00155     blockquote
() ;
00156     
00157     p
("texte") ;
00158     echo "Nous allons donc progressivement apprendre des mots et les utiliser dans des phrases courtes, " 
;
00159     echo " puis r&eacute;fl&eacute;chir pour savoir comment construire des phrases longues, " 
;
00160     echo " produire automatiquement des s&eacute;ries de phrases, automatiser des comportements..." 
;
00161     finp
() ;
00162     
00163     p
("texte") ;
00164     echo "Une des difficult&eacute;s sera de comprendre comment l'ordinateur comprend nos phrases, de mettre en " 
;
00165     echo " place des automatismes, des habitudes de programmation." 
;
00166     finp
() ;
00167     
00168     p
("texte") ;
00169     echo "Le cours 1 (ce cours) insiste sur les principes g&eacute;n&eacute;raux et doit convaincre des qualit&eacute;s qu'il faut " 
;
00170     echo " d&eacute;velopper pour savoir programmer. " 
;
00171     echo " Le cours 2 sera focalis&eacute; sur la notion de variable et d'affectation (calcul ou remplacement de variable). " 
;
00172     echo " Le cours 3 sert &agrave; apprendre comment indiquer &agrave; l'ordinateur quelles instructions r&eacute;aliser en fonction de " 
;
00173     echo " conditions sur les valeurs des variables (ce qu'on nomme tests logiques). " 
;
00174     echo " Les boucles et it&eacute;rations seront pr&eacute;sent&eacute;es au cours 4 alors que les sous-programmes seront trait&eacute;s dans le cours 5." 
;
00175     echo " Les autres cours serviront &agrave; indiquer tout le travail qu'il reste &agrave; faire pour savoir \"bien\" programmer en R." 
;
00176     finp
() ;
00177     
00178     finblockquote
() ;
00179     
00180     #######################################################################################################################
00181     
00182     $tdmCRLM1
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Qu'est-ce que la programmation ?
00183     
00184     ## -------------------------------------------------------------------------------------------
00185     
00186     blockquote
() ;
00187     
00188     $sous 
# num&eacute;ro de sous-rubrique
00189     
00190     p
("texte") ;
00191     echo "Avant de rentrer dans le d&eacute;tail des instructions de programmation, voici quelques exemples de situation " 
;
00192     echo " pour expliciter les grands principes de la programmation. Vous en d&eacute;duirez facilement les qualit&eacute;s et comp&eacute;tences requises " 
;
00193     echo " pour savoir programmer..." 
;
00194     finp
() ;
00195     
00196     
00197     ## -------------------------------------------------------------------------------------------
00198     
00199     $sous
++ ; h3("$numRub".".$sous Programmer, c'est r&eacute;fl&eacute;chir et organiser") ;
00200     
00201     ## -------------------------------------------------------------------------------------------
00202     
00203     blockquote
() ;
00204     
00205     p
("texte") ;
00206     echo "Imaginons que nous cherchions ce qu'on nomme "
.b("maximum")." d'une s&eacute;rie de valeurs, c'est-&agrave;-dire la plus " ;
00207     echo " grande valeur. " 
;
00208     finp
() ;
00209     
00210     p
("texte") ;
00211     echo "Prenons par exemple les valeurs "
.b("1&nbsp;8&nbsp;2&nbsp;5&nbsp;8&nbsp;7&nbsp;8").". " ;
00212     echo " Je suis s&ucirc;r que vous avez trouv&eacute; le maximum qui est "
.b("8").". "  ;
00213     echo " Mais de quel  "
.b("8")." s'agit-il&nbsp;?" ;
00214     echo " Est-ce le premier&nbsp;?" 
;
00215     echo "  Le second&nbsp;?" 
;
00216     echo "  Le dernier&nbsp;?" 
;
00217     finp
() ;
00218     
00219     p
("texte") ;
00220     echo "Et comment avez-vous fait&nbsp;? Avez-vous pass&eacute; en revue toutes les valeurs &agrave; " 
;
00221     echo " partir du d&eacute;but&nbsp;? Ou &agrave; partir de la fin&nbsp;?" 
;
00222     finp
() ;
00223     
00224     p
("texte") ;
00225     echo "Et s'il s'agissait de pourcentages, vu que le maximum est 100&nbsp;%, est-ce que cela " 
;
00226     echo " changerait quelque chose &agrave; votre fa&ccedil;on de chercher le maximum&nbsp;?" 
;
00227     finp
() ;
00228     
00229     p
("texte") ;
00230     echo "Imaginons maintenant que nous voulions le maximum, le nombre de fois o&ugrave; il apparait et la (ou les) positions o&ugrave; il apparait. " 
;
00231     echo " Sachant que la liste des valeurs est longue pour un humain (disons une centaine de valeurs), sauriez-vous r&eacute;soudre ce " 
;
00232     echo " probl&egrave;me en ne passant en revue la liste qu'une seule fois&nbsp;?" 
;
00233     finp
() ;
00234     
00235     p
("texte") ;
00236     echo "Programmer, c'est aussi se poser ce genre de questions. En cas de tr&egrave;s grandes listes pour " 
;
00237     echo " l'ordinateur (par exemple si chaque valeur est obtenue au bout d'un long calcul), il faut " 
;
00238     echo rouge
("r&eacute;fl&eacute;chir")." pour trouver une m&eacute;thode rapide. " ;
00239     echo " Passer en revue la liste une premi&egrave;re fois pour trouver le maximum et la passer en revue une seconde fois " 
;
00240     echo " pour calculer le nombre d'occurences et les positions du maximum est une m&eacute;thode simple mais non rapide. " 
;
00241     finp
() ;
00242     
00243     p
("texte") ;
00244     echo "L'usage veut donc qu'avant de commencer &agrave; programmer on r&eacute;fl&eacute;chisse au probl&egrave;me, aux entr&eacute;es et aux sorties, " 
;
00245     echo " aux fonctionnalit&eacute;s de ce qu'on veut faire, aux dur&eacute;es possibles et pr&eacute;voir en retour ce qu'on va programmer... " 
;
00246     finp
() ;
00247     
00248     finblockquote
() ;
00249     
00250     ## -------------------------------------------------------------------------------------------
00251     
00252     $sous
++ ; h3("$numRub".".$sous Programmer, c'est choisir et expliciter ses choix") ;
00253     
00254     ## -------------------------------------------------------------------------------------------
00255     
00256     blockquote
() ;
00257     
00258     p
("texte") ;
00259     echo "Voici un exemple classique qui fait partie de la programmation traditionnelle&nbsp;:" 
;
00260     echo " construire le nom d'un fichier de sortie &agrave; partir d'un fichier d'entr&eacute;e. " 
;
00261     echo " Par exemple on veut, &agrave; partir du fichier "
.bleu("serie35.xls")." construire le fichier ".bleu("serie35.txt") ;
00262     echo " ou encore, &agrave; partir de "
.vert("serie_1.manip2.rep036.xls")." construire ".vert("serie_1.manip2.rep036.txt").". " ;
00263     finp
() ;
00264     
00265     p
("texte") ;
00266     echo "Vous voyez certainement ce qu'il faut faire&nbsp;: rep&eacute;rer le \"bon\" point qui indique la fin du nom de fichier " 
;
00267     echo " (ce n'est donc pas le premier point qu'on rencontre dans le nom de fichier, mais plut&ocirc;t le dernier), puis " 
;
00268     echo " extraire la partie avant ce point et rajouter "
.b("txt")." ou ".b(".txt")." suivant qu'on a d&eacute;j&agrave; extrait le point ou non. " ;
00269     finp
() ;
00270     
00271     p
("texte") ;
00272     echo " Si les m&eacute;thodes "
.em(vert("extraire la premi&egrave;re partie avec le point"))." et ".em(vert("sans le point")) ;
00273     echo " sont sans doute &eacute;quivalentes en terme de simplicit&eacute; et de vitesse, " 
;
00274     echo " quelle est la meilleure m&eacute;thode&nbsp;? Et selon quels crit&egrave;res&nbsp;?" 
;
00275     echo " Une fois que vous aurez trouv&eacute; ce qui est la meilleure m&eacute;thode pour vous (et vos fichiers) -- ce qui n'est peut-&ecirc;tre pas " 
;
00276     echo " la m&ecirc;me meilleure m&eacute;thode que pour vos coll&egrave;gues -- il faut le noter, documenter ce choix pour &eacute;viter de se poser la " 
;
00277     echo " question &agrave; nouveau et "
.b("toujours s'y tenir").", ce qui peut se faire en &eacute;crivant un sous-programme qui r&eacute;alise ce traitement." ;
00278     finp
() ;
00279     
00280     finblockquote
() ;
00281     
00282     ## -------------------------------------------------------------------------------------------
00283     
00284     $sous
++ ; h3("$numRub".".$sous Programmer, c'est tester, pr&eacute;voir et valider") ;
00285     
00286     ## -------------------------------------------------------------------------------------------
00287     
00288     blockquote
() ;
00289     
00290     p
("texte") ;
00291     echo "Reprenons l'exemple pr&eacute;c&eacute;dent de construction d'un nom de fichier en sortie. Nous avions bas&eacute; notre  " 
;
00292     echo " analyse sur le fait qu'il y avait un point en fin de nom de fichier d'entr&eacute;e. Et si ce n'&eacute;tait pas le cas&nbsp;?" 
;
00293     echo " C'est ce qui risque d'arriver non pas en ligne, si on tape le nom du fichier, mais si le nom du fichier d'entr&eacute;e " 
;
00294     echo " a par exemple &eacute;t&eacute; mal construit par un autre programme. Que fait la m&eacute;thode pr&eacute;c&eacute;dente&nbsp;? " 
;
00295     finp
() ;
00296     
00297     p
("texte") ;
00298     echo "La r&eacute;ponse d&eacute;pend de la fa&ccedil;on dont vous avez d&eacute;tect&eacute; le point. Certaines fonctions renvoient, lorsque le point n'est pas " 
;
00299     echo" trouv&eacute;, la valeur -1, d'autres une valeur &eacute;gale &agrave; \"1 de plus que la longueur du nom de fichier\". " 
;
00300     echo " Ces deux choix se valent, le plus important est d'y avoir pens&eacute; car ce qu'il faut faire dans ce cas d&eacute;pend " 
;
00301     echo " de la valeur renvoy&eacute;e. " 
;
00302     finp
() ;
00303     
00304     p
("texte") ;
00305     echo "Nous essaierons, dans le cadre des exercices pr&eacute;sent&eacute;s, de pr&eacute;voir les cas usuels classiques d'erreur (fichier non pr&eacute;sent " 
;
00306     echo " ou faute de frappe, liste vide de valeurs...) afin d'avoir des programmes dits "
.b("robustes")." et ".b("fiables").". " ;
00307     finp
() ;
00308     
00309     p
("texte") ;
00310     echo "Cela signifie qu'en cons&eacute;quence il faudra tester diff&eacute;rents cas classiques afin de valider le \"bon\" comportement " 
;
00311     echo " de nos programmes dans les conditions normales d'application et de g&eacute;rer les cas exceptionnels. " 
;
00312     finp
() ;
00313     
00314     p
("texte") ;
00315     echo " En particulier, il faudra r&eacute;fl&eacute;chir, organiser et pr&eacute;voir ce qu'on fait par exemple si un fichier n'est pas vu alors " 
;
00316     echo " qu'on traite une liste de fichiers. Interrompre le programme pour demander un nouveau nom est peut-&ecirc;tre inadapt&eacute;, " 
;
00317     echo " tout arr&ecirc;ter est sans doute trop brutal, se contenter d'afficher un message d'erreur est certainement maladroit " 
;
00318     echo " parce qu'il risque de disparaitre si la " 
;
00319     echo " liste des fichiers &agrave; traiter est longue..." 
;
00320     finp
() ;
00321     
00322     finblockquote
() ;
00323     
00324     ## -------------------------------------------------------------------------------------------
00325     
00326     $sous
++ ; h3("$numRub".".$sous Programmer demande de l'endurance, de la pr&eacute;cision et de la rigueur") ;
00327     
00328     ## -------------------------------------------------------------------------------------------
00329     
00330     blockquote
() ;
00331     
00332     p
("texte") ;
00333     echo "Au vu des situations pr&eacute;sent&eacute;es ci-dessus, il est clair que la programmation n'est pas au d&eacute;part " 
;
00334     echo " une partie de plaisir puisqu'il faut r&eacute;fl&eacute;chir, trouver une \"bonne\" solution -- souvent un compromis entre " 
;
00335     echo " simplicit&eacute; et vitesse d'ex&eacute;cution, penser aux erreurs possibles... " 
;
00336     finp
() ;
00337     
00338     p
("texte") ;
00339     echo "Par contre, c'est au final une r&eacute;elle joie que d'avoir un programme qui \"tourne\" sans \"bugger\" ou \"boucler\", " 
;
00340     echo " que d'obtenir presque "
.b("automatiquement")." toute une s&eacute;rie de r&eacute;sultats et de fichiers sans avoir de nombreux " ;
00341     echo " copier/coller ou de fastidieuses manipulations &agrave; faire et &agrave; refaire, de fournir &agrave; la communaut&eacute; un " 
;
00342     echo " programme qui peut aider d'autres coll&egrave;gues et faire gagner ainsi beaucoup de temps, cette denr&eacute;e rare..." 
;
00343     finp
() ;
00344     
00345     ## -------------------------------------------------------------------------------------------
00346     
00347     finblockquote
() ;
00348     
00349     finblockquote
() ;
00350     
00351     #######################################################################################################################
00352     
00353     $tdmCRLM1
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Sp&eacute;cificit&eacute;s du langage $R
00354     
00355     ## -------------------------------------------------------------------------------------------
00356     
00357     blockquote
() ;
00358     
00359     p
("texte") ;
00360     echo "La programmation en 
$R ressemble au d&eacute;part &agrave; la programmation traditionnelle. " ;
00361     echo " Ce qui change beaucoup, c'est principalement le fait que 
$R est ".rouge("vectoriel").", qu'on utilise un " ;
00362     echo " environnement qui sauvegarde les variables et qu'il y a des milliers de fonctions de base et des milliers " 
;
00363     echo " de fonctions compl&eacute;mentaires  disponibles dans des "
.b("packages").". " ;
00364     echo " Du coup, de nombreuses actions (trier, calculer, tracer...) sont soit &eacute;l&eacute;mentaires soit d&eacute;j&agrave; programm&eacute;es." 
;
00365     finp
() ;
00366     
00367     finblockquote
() ;
00368     
00369     #######################################################################################################################
00370     #
00371     # progic2
00372     #
00373     #######################################################################################################################
00374     
00375     $numcours 
partie($numcours) ; pvide() ;
00376     $rubrique  
;
00377     $rubriques2 
= array() ;
00378     $rubrique
++ ; $rubriques2[$rubrique] = "Variables simples et affectations" ;
00379     $rubrique
++ ; $rubriques2[$rubrique] = "Structures de donn&eacute;es et affectations en $R;
00380     $rubrique
++ ; $rubriques2[$rubrique] = "Autres \"objets\" en $R";
00381     $rubrique
++ ; $rubriques2[$rubrique] = "Affichage des variables en $R";
00382     $rubrique
++ ; $rubriques2[$rubrique] = "Sp&eacute;cificit&eacute;s du langage $R";
00383     
00384     $tdmCRLM2 
= new tdm($rubriques2) ;
00385     $tdmCRLM2
->titre() ;
00386     $tdmCRLM2
->menu("oui","oui","nou","p$numcours") ;
00387     
00388     $numRub 
;
00389     
00390     #######################################################################################################################
00391     
00392     $tdmCRLM2
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Variables simples et affectations
00393     
00394     ## -------------------------------------------------------------------------------------------
00395     
00396     blockquote
() ;
00397     
00398     p
("texte") ;
00399     echo "Une "
.b("variable")." est semblable &agrave; une boite dot&eacute;e d'un nom (ou ".em("identifiant").") " ;
00400     echo " qui contient une valeur (nomm&eacute;e aussi "
.em("contenu de la variable")."). "  ;
00401     echo " R&eacute;aliser une "
.b("affectation").", c'est mettre une valeur dans une variable, " ;
00402     echo " qu'il s'agisse d'une valeur num&eacute;rique ou caract&egrave;re ou autre. " 
;
00403     echo " Mettre une valeur dans une variable pour la premi&egrave;re fois se nomme "
.b("initialiser")." la variable. " ;
00404     echo " Contrairement &agrave; d'autres langages de programmation il n'y a pas besoin en 
$R de pr&eacute;venir (".em("\"d&eacute;clarer\"") ;
00405     echo " ou \"typer\" cette variable) en pr&eacute;venant ce qu'elle va contenir, un nombre, du texte, etc. " 
;
00406     echo " On utilise en 
$R les symboles accol&eacute;s tiret et sup&eacute;rieur (ce qui ressemble un peu &agrave; une fl&egrave;che) pour indiquer " ;
00407     echo " le contenu et la variable. " 
;
00408     echo " Deux syntaxes sont possibles en 
$R&nbsp;:" ;
00409     finp
() ;
00410     
00411     pre_fichier
("syntaxe1.txt","cadre") ;
00412     
00413     
00414     p
("texte") ;
00415     echo "La premi&egrave;re forme avec d'abord le nom de la variable est la plus classique mais la seconde est la plus explicite " 
;
00416     echo " et sans doute la plus compr&eacute;hensible. " 
;
00417     echo " La machine commence toujours par &eacute;valuer (calculer) la partie du cot&eacute; du tiret de la fl&egrave;che, ce qui explique que l'instruction " 
;
00418     finp
() ;
00419     
00420     pre_fichier
("syntaxe2.txt","cadre") ;
00421     
00422     
00423     p
("texte") ;
00424     echo "a un sens qui signifie "
.b("rajouter un &agrave;  la variable").", ce qui se dit ".b("incr&eacute;menter la variable").". " ;
00425     finp
() ;
00426     
00427     p
("texte") ;
00428     echo "Lorsque la machine ex&eacute;cute \"le code\" (les instructions), elle proc&eacute;de "
.b("en s&eacute;quence")." c'est-&agrave;-dire qu'elle ex&eacute;cute " ;
00429     echo " les instructions les unes &agrave; la suite des autres. C'est un peu un &laquo;jeu de piste&raquo; que de trouver ce que " 
;
00430     echo " fait la machine lorsqu'on lit les instructions. Ainsi avec le code "
;
00431     finp
() ;
00432     
00433     pre_fichier
("syntaxe3.txt","cadre") ;
00434     
00435     
00436     p
("texte") ;
00437     echo " on trouve 3 dans la variable "
.vert("a")." et 6 dans la variable ".vert("b").", ce qui se nomme " ;
00438     echo b
("permuter les variables")." alors qu'avec le code " ;
00439     finp
() ;
00440     
00441     pre_fichier
("syntaxe4.txt","cadre") ;
00442     
00443     p
("texte") ;
00444     echo " on n'obtient rien de particulier (ou, plut&ocirc;t, si, &nbsp; on perd la valeur de "
.vert("a")."). " ;
00445     finp
() ;
00446     
00447     p
("texte") ;
00448     echo rouge
("Conclusion&nbsp;").":" ;
00449     echo " il faut &ecirc;tre tr&egrave;s prudent(e), bien se relire, bien tout v&eacute;rifier car on a vite fait de se tromper, " 
;
00450     echo " surtout si on tape vite sur le clavier. " 
;
00451     finp
() ;
00452     
00453     p
("texte") ;
00454     echo "Pour ceux et celles qui n'ont pas compris le d&eacute;tail de la permutation des variables, voici les explications " 
;
00455     echo " &eacute;crites directement dans le code &agrave; l'aide de commentaires rep&eacute;r&eacute;s par le symbole di&egrave;se (#). La machine ne tient pas " 
;
00456     echo " compte du di&egrave;se et de ce qui le suit. " 
;
00457     echo " Il est conseil&eacute; de mettre &laquo;"
.em("suffisamment")."&raquo; de commentaires afin de pouvoir se relire et que les " ;
00458     echo " autres personnes qui lisent le code puissent le comprendre." 
;
00459     finp
() ;
00460     
00461     pre_fichier
("syntaxe5.txt","cadre") ;
00462     
00463     p
("texte") ;
00464     echo "Il existe bien s&ucirc;r des solutions plus simples, plus g&eacute;n&eacute;rales pour r&eacute;aliser cette permutation. " 
;
00465     #echo " Voir l'".href("progie2.php?solutions=0#tdm1","exercice 1")."." ;
00466     finp
() ;
00467     
00468     p
("texte") ;
00469     echo "Le choix du nom des variables (en particulier le nombre de lettres de l'identifiant) et la fa&ccedil;on de les &eacute;crire ne sont pas " 
;
00470     echo " impos&eacute;s, mais il existe plusieurs m&eacute;thodes et surtout quelques conseils de bon sens. " 
;
00471     #echo " Voir l'".href("progie2.php?solutions=0#tdm2","exercice 2")."." ;
00472     finp
() ;
00473     
00474     
00475     finblockquote
() ;
00476     
00477     #######################################################################################################################
00478     
00479     $tdmCRLM2
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Structures de donn&eacute;es et affectations en $R
00480     
00481     ## -------------------------------------------------------------------------------------------
00482     
00483     blockquote
() ;
00484     
00485     # vecteurs et listes
00486     
00487     p
("texte") ;
00488     echo "
$R est un langage ".rouge("vectoriel") ;
00489     echo " ce qui signifie que les "
.bleu("vecteurs")." sont les &eacute;l&eacute;ments de base du langage. " ;
00490     echo " On peut cr&eacute;er des vecteurs de diff&eacute;rentes fa&ccedil;ons, par exemple avec " 
;
00491     echo lafonction
("c") ;
00492     echo ", " 
;
00493     echo lafonction
("seq") ;
00494     echo ", " 
;
00495     echo lafonction
("vector") ;
00496     echo ", " 
;
00497     echo lafonction
("rep") ;
00498     echo " ou son raccourci "
.rouge(":")." (le symbole deux-points)... " ;
00499     echo " Gr&acirc;ce &agrave; " 
;
00500     echo lafonction
("identical") ;
00501     echo ", il est facile de v&eacute;rifier que "
.b("x")." et ".b("c(x)")." repr&eacute;sentent le m&ecirc;me objet. " ;
00502     echo " Le nombre d'&eacute;l&eacute;ments d'un vecteur se nomme sa "
.b("longueur")." et s'obtient en $R &agrave; l'aide de " ;
00503     echo lafonction
("length") ;
00504     echo "." 
;
00505     finp
() ;
00506     
00507     pre_fichier
("syntaxe6.txt","cadre") ;
00508     
00509     
00510     p
("texte") ;
00511     echo "En 
$R, ".rouge("a:b")." correspond aux vecteurs des entiers qui vont de ".rouge("a")." &agrave; ".rouge("b").". " ;
00512     echo " Voici quelques exemples&nbsp;:" 
;
00513     finp
() ;
00514     
00515     pre_fichier
("syntaxe7.txt","cadre") ;
00516     
00517     
00518     p
("texte") ;
00519     echo "Comme le montrent les trois derniers exemples, 
$R connait le ".b("calcul vectoriel")."&nbsp;:"  ;
00520     echo " additionner 1 &agrave; un vecteur, c'est ajouter 1 &agrave; chacun des &eacute;l&eacute;ments du vecteur. De m&ecirc;me, 
$R sait " ;
00521     echo " additionner "
.em(b("naturellement"))." des vecteurs de m&ecirc;me longueur, les multiplier... " ;
00522     echo " Il faut donc "
.bleu("imp&eacute;rativement")." utiliser des parenth&egrave;ses en cas de doute sur une op&eacute;ration ou r&eacute;aliser une " ;
00523     echo " affectation suppl&eacute;mentaire pour obtenir un "
.b("code lisible")."&nbsp;:" ;
00524     finp
() ;
00525     
00526     pre_fichier
("syntaxe8.txt","cadre") ;
00527     
00528     p
("texte") ;
00529     echo "Maitriser la notation deux-points et les op&eacute;rations vectorielles &eacute;l&eacute;mentaires est tr&egrave;s important parce que " 
;
00530     echo" cela permet d'effectuer de nombreux calculs et de g&eacute;n&eacute;rer de nombreuses valeurs "
.b("&agrave; moindre frappe").". " ;
00531     #echo " Voir l'".href("progie2.php?solutions=0#tdm3","exercice 3")."." ;
00532     finp
() ;
00533     
00534     p
("texte") ;
00535     echo "En plus des vecteurs, 
$R dispose des ".bleu("listes")." comme &eacute;lements de base. "  ;
00536     echo " Une liste nomm&eacute;e (nous ne conseillons pas d'utiliser des listes non nomm&eacute;es) se d&eacute;finit via le mot " 
;
00537     echo " anglais "
.b(hrrr("list"))." -- on s'en serait dout&eacute;&nbsp;! On acc&egrave;de aux &eacute;l&eacute;ments d'une liste nomm&eacute;e via leur nom " ;
00538     echo " et le symbole "
.b("\$")." (dollar). " ;
00539     echo " Le nombre d'&eacute;l&eacute;ments d'une liste se nomme sa "
.b("longueur")." et s'obtient en $R &agrave; l'aide de " ;
00540     echo lafonction
("length") ;
00541     echo " mais attention car une liste peut contenir plein de choses, des vecteurs, d'autres listes, etc. " 
;
00542     echo " Voici quelques exemple qui se veulent explicites&nbsp;:" 
;
00543     finp
() ;
00544     
00545     pre_fichier
("syntaxe9.txt","cadre") ;
00546     
00547     
00548     finblockquote
() ;
00549     
00550     #######################################################################################################################
00551     
00552     $tdmCRLM2
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # "Autres \"objets\" en $R
00553     
00554     ## -------------------------------------------------------------------------------------------
00555     
00556     blockquote
() ;
00557     
00558     # matrices et dataframes
00559     
00560     p
("texte") ;
00561     echo "
$R dispose aussi de deux structures de donn&eacute;es tr&egrave;s importantes issues des vecteurs et des listes&nbsp;:" ;
00562     echo " ce sont les "
.b("matrices")." et les ".b("data frames")." qui permettent de repr&eacute;senter respectivement des tableaux " ;
00563     echo " homog&egrave;nes et h&eacute;t&eacute;rog&egrave;nes classiques avec des lignes et des colonnes. " 
;
00564     echo " Nous y reviendrons plus tard." 
;
00565     echo " Signalons aussi qu'il existe des tableaux g&eacute;n&eacute;raux ("
.b("array").") mais dont on se passe la plupart du temps&nbsp;!" ;
00566     finp
() ;
00567     
00568     p
("texte") ;
00569     echo "Pour connaitre la nature d'on objet, on peut utiliser "
.lafonction("class")."&nbsp;:" ;
00570     finp
() ;
00571     
00572     pre_fichier
("class.txt","cadre") ;
00573     
00574     p
("texte") ;
00575     echo "
$R a aussi des valeurs \"sp&eacute;ciales\" nomm&eacute;es ".b("NA").", et ".b("NULL")." dont nous reparlerons plus tard, comme les r&eacute;sultats " ;
00576     echo b
("Inf").", "b("NAN")." et ".b("&lt;NA&gt;").". " ;
00577     finp
() ;
00578     
00579     
00580     p
("texte") ;
00581     echo "Pour les plus impatient(e)s, le lien sous ces mots dans le tableau suivant m&egrave;ne &agrave; l'aide de 
$R pour ces valeurs&nbsp;:" ;
00582     finp
() ;
00583     
00584     blockquote
() ;
00585     table
(1,8,"collapse bleu_pastel") ;
00586      entetesTableau
("mot signification","jaune_pastel") ;
00587     
00588      tr
() ;
00589         td
("") ;
00590           nbsp
() ;
00591           echo href
("http://finzi.psych.upenn.edu/R/library/base/html/NA.html","NA","gvertf") ;
00592           nbsp
() ;
00593         fintd
() ;
00594         td
() ;
00595           echo "Not Available" 
;
00596         fintd
() ;
00597      fintr
() ;
00598     
00599      tr
() ;
00600         td
() ;
00601           nbsp
() ;
00602           echo href
("http://finzi.psych.upenn.edu/R/library/base/html/NULL.html","NULL","gvertf") ;
00603           nbsp
() ;
00604         fintd
() ;
00605         td
() ;
00606           echo "Rien (!)" 
;
00607         fintd
() ;
00608      fintr
() ;
00609     
00610      tr
() ;
00611         td
() ;
00612           nbsp
() ;
00613           echo href
("http://finzi.psych.upenn.edu/R/library/base/html/is.finite.html","NAN","gvertf") ;
00614           nbsp
() ;
00615         fintd
() ;
00616         td
() ;
00617           echo "Not a number (pas un nombre)" 
;
00618         fintd
() ;
00619      fintr
() ;
00620     
00621      tr
() ;
00622         td
() ;
00623           nbsp
() ;
00624           echo href
("http://finzi.psych.upenn.edu/R/library/base/html/is.finite.html","Inf","gvertf") ;
00625           nbsp
() ;
00626         fintd
() ;
00627         td
() ;
00628           echo "Infini" 
;
00629         fintd
() ;
00630      fintr
() ;
00631     
00632     fintable
() ;
00633     finblockquote
() ;
00634     
00635     p
() ;
00636     #echo " Voir l'".href("progie2.php?solutions=0#tdm4","exercice 4")."." ;
00637     finp
() ;
00638     
00639     finblockquote
() ;
00640     
00641     #######################################################################################################################
00642     
00643     $tdmCRLM2
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  Affichage des variables en R
00644     
00645     ## -------------------------------------------------------------------------------------------
00646     
00647     # print cat paste et sprintf
00648     
00649     blockquote
() ;
00650     
00651     p
("texte") ;
00652     echo "On dispose de deux fonctions principales pour afficher les variables&nbsp;:" 
;
00653     echo lafonction
("print") ;
00654     echo " et " 
;
00655     echo lafonction
("cat").". " ;
00656     echo " De plus on peut utiliser "
.hrrr("paste")." et ".hrrr("sprintf") ;
00657     echo " pour respectivement concat&eacute;ner des chaines ou les formater." 
;
00658     echo " Voici un petit pot-pourri qui montre la puissance de ces fonctions&nbsp;: " 
;
00659     #echo " sachant que lorsque $R affiche ".b("[nn]")." il s'agit de l'indice du premier &eacute;l&eacute;ment affich&eacute;&nbsp;:" ;
00660     finp
() ;
00661     
00662     pre_fichier
("affiche.txt","cadre") ;
00663     
00664     finblockquote
() ;
00665     
00666     #######################################################################################################################
00667     
00668     $tdmCRLM2
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Sp&eacute;cificit&eacute;s du langage R
00669     
00670     ## -------------------------------------------------------------------------------------------
00671     
00672     blockquote
() ;
00673     
00674     p
("texte") ;
00675     echo "
$R est un langage particulier puisqu'il est ".rouge("vectoriel").". "  ;
00676     echo " Du coup, on dispose facilement de s&eacute;ries de valeurs et de calculs "
.em("idoines")." " ;
00677     echo " et en particulier on peut appliquer &agrave; des vecteurs des fonctions statistiques et math&eacute;matiques comme " 
;
00678     echo hrrr
("sum").", ";
00679     echo hrrr
("mean").", ";
00680     echo href
("http://finzi.psych.upenn.edu/R/library/base/html/Extremes.html","min","gvertf").", " ;
00681     echo href
("http://finzi.psych.upenn.edu/R/library/base/html/Extremes.html","max","gvertf")."... " ;
00682     finp
() ;
00683     
00684     pre_fichier
("applique.txt","cadre") ;
00685     
00686     p
("texte") ;
00687     echo " De fa&ccedil;on subtile, 
$R distingue les entiers des r&eacute;els. Ainsi ".b("1")." est un r&eacute;el alors que " ;
00688     echo b
("1L")." est un entier. Comme ".rouge(":")." renvoie des entiers, il est normal que " ;
00689     echo b
("1:2")." ne soit pas &eacute;gal &agrave; ".b("c(1,2)")." mais bien &agrave; ".b("c(1L,2L)").". " ;
00690     finp
() ;
00691     
00692     p
("texte") ;
00693     echo "Il faut aussi noter que les vecteurs sont toujours \"plats\", homog&egrave;nes en type et que 
$R convertit sans pr&eacute;venir. " ;
00694     echo " Cela peut avoir de graves cons&eacute;quences&nbsp;:" 
;
00695     finp
() ;
00696     
00697     pre_fichier
("conversion.txt","cadre") ;
00698     
00699     p
("texte") ;
00700     echo "Signalons au passage que les fonctions sont des variables et qu'on peut donc les inclure dans des listes... " 
;
00701     finp
() ;
00702     
00703     pre_fichier
("foncvar.txt","cadre") ;
00704     
00705     p
("texte") ;
00706     echo "Enfin, il faut noter que l'affectation est aussi une fonction. La notation "
.b("&lt;-")." n'est qu'un raccourci d'&eacute;criture&nbsp;:" ;
00707     finp
() ;
00708     
00709     pre_fichier
("foncaffect.txt","cadre") ;
00710     
00711     finblockquote
() ;
00712     
00713     #######################################################################################################################
00714     #
00715     # progic3
00716     #
00717     #######################################################################################################################
00718     
00719     $numcours 
partie($numcours) ; pvide() ;
00720     $rubrique  
;
00721     $rubriques3 
= array() ;
00722     $rubrique
++ ; $rubriques3[$rubrique] = "Valeurs logiques et tests en $R;
00723     $rubrique
++ ; $rubriques3[$rubrique] = "Filtrage vectoriel" ;
00724     $rubrique
++ ; $rubriques3[$rubrique] = "Applications aux matrices et ".em("dataframes") ;
00725     $rubrique
++ ; $rubriques3[$rubrique] = "Sp&eacute;cificit&eacute;s du langage $R";
00726     
00727     $tdmCRLM3 
= new tdm($rubriques3) ;
00728     $tdmCRLM3
->titre() ;
00729     $tdmCRLM3
->menu("oui","oui","nou","p$numcours") ;
00730     
00731     $numRub 
;
00732     
00733     #######################################################################################################################
00734     
00735     $tdmCRLM3
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Valeurs logiques et tests en R
00736     
00737     ## -------------------------------------------------------------------------------------------
00738     
00739     blockquote
() ;
00740     
00741     p
("texte") ;
00742     echo "
$R dispose de deux valeurs logiques nomm&eacute;es ".b("FALSE")." et ".b("TRUE")." qui valent num&eacute;riquement 0 et 1. " ;
00743     echo " Les op&eacute;rateurs qui renvoient des valeurs logiques sont tr&egrave;s classiquement "
.b("&lt;")." et ".b("&gt;").". " ;
00744     echo " Il faut leur adjoindre "
.b("&lt;=")." et ".b("&gt;=")." et aussi ".b("==")." (bien noter qu'il y a deux signes \"&eacute;gal\") " ;
00745     echo " pour tester l'&eacute;galit&eacute;. Pour des variables simples, " 
;
00746     echo " les connecteurs usuels nomm&eacute;s "
.b("NON").", ".b("ET").", ".b("OU")." s'&eacute;crivent respectivement " ;
00747     echo b
("!").", ".b("&amp;").", ".b("|").". Il est tr&egrave;s fortement conseill&eacute; d'utiliser des parenth&egrave;ses pour s&eacute;parer ces comparaisons logiques. " ;
00748     echo " Voici quelques exemples d'utilisation&nbsp;:" 
;
00749     finp
() ;
00750     
00751     pre_fichier
("tests1.txt","cadre") ;
00752     
00753     p
("texte") ;
00754     echo "Pour r&eacute;aliser un test logique, on utilise une structure algorithmique dite d'alternative " 
;
00755     echo " qui, en fonction d'une condition (op&eacute;ration &agrave; r&eacute;sultat logique), effectue une bloc d'instructions. " 
;
00756     echo " Voici les deux formes algorithmiques, nomm&eacute;es respectivement SI_ALORS et SI_ALORS_SINON&nbsp;:" 
;
00757     finp
() ;
00758     
00759     pre_fichier
("tests2.txt","cadre") ;
00760     
00761     p
("texte") ;
00762     echo "La traduction en 
$R se fait &agrave; l'aide des mots ".b("if").", ".b("else")." et des accolades " ;
00763     echo b
("{")." et ".b("}")." pour d&eacute;limiter les blocs d'instruction. De telles structures permettent donc " ;
00764     echo " de "
.rouge("modifier l'ex&eacute;cution en s&eacute;quence des instructions").". " ;
00765     finp
() ;
00766     
00767     pre_fichier
("tests3.txt","cadre") ;
00768     
00769     p
("texte") ;
00770     echo "Voici deux exemples en 
$R. " ;
00771     echo " On remarquera que nous avons (ce qui est tr&egrave;s fortement conseill&eacute;) comment&eacute; les " 
;
00772     echo " fins de SI. " 
;
00773     finp
() ;
00774     
00775     pre_fichier
("tests4.txt","cadre") ;
00776     
00777     p
("texte") ;
00778     echo "L'instruction "
.b("stop")." en $R permet de quitter le script en cours. Cela " ;
00779     echo " peut se r&eacute;v&eacute;ler utile, par exemple si le fichier que l'on veut traiter n'est pas trouv&eacute; (noter le mot " 
;
00780     echo b
("si")." dans cette phrase). Voici comment s'en servir&nbsp;:" ;
00781     finp
() ;
00782     
00783     pre_fichier
("tests5.txt","cadre") ;
00784     
00785     p
("texte") ;
00786     echo "La valeur "
.b("NA")." de $R qui signifie ".em("Not Available").", soit ".b("Non Accessible")." en fran&ccedil;ais est " ;
00787     echo " aussi une valeur logique ce qui complique les cas &agrave; tester&nbsp;:" 
;
00788     finp
() ;
00789     
00790     pre_fichier
("testsna.r","cadre") ;
00791     
00792     finblockquote
() ;
00793     
00794     #######################################################################################################################
00795     
00796     $tdmCRLM3
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  Filtrage vectoriel
00797     
00798     ## -------------------------------------------------------------------------------------------
00799     
00800     blockquote
() ;
00801     
00802     p
("texte") ;
00803     echo "
$R est beaucoup plus puissant avec les tests logiques qu'on ne l'imagine " ;
00804     echo " car on peut coupler l'indexation avec ces tests " 
;
00805     echo " et donc r&eacute;aliser des "
.ghRouge(em("affectations conditionnelles")).". " ;
00806     finp
() ;
00807     
00808     p
("texte") ;
00809     echo " Pour acc&eacute;der &agrave; un &eacute;l&eacute;ment dans un vecteur, " 
;
00810     echo 
$R fournit la notation \"crochets\"&nbsp;: ainsi ".b("x[k]")." correspond &agrave; l'&eacute;l&eacute;ment num&eacute;ro ".b("k")." sachant que, " ;
00811     echo " contrairement &agrave; la plupart des autres langages de programmation, 
$R commence la num&eacute;rotation &agrave; 1. Donc ".b("x[0]")." -- qui existe par ailleurs  " ;
00812     echo " en 
$R -- ne correspond pas au premier &eacute;l&eacute;ment de ".b("x")."." ;
00813     finp
() ;
00814     
00815     p
("texte") ;
00816     echo " La notation crochets ou "
.b("indexation")." permet de sp&eacute;cifier plusieurs &eacute;l&eacute;ments. Ainsi ".b("[1:n]")." correspond aux ".b("n")." premiers &eacute;l&eacute;ments. " ;
00817     echo " Un indice entier mais n&eacute;gatif signifie "
.b("tout sauf cet indice")." donc " ;
00818     echo b
("(1:5)[&nbsp;-&nbsp;c(3,4)&nbsp;]")." renvoie ".b("1&nbsp;2&nbsp;5").". " ;
00819     finp
() ;
00820     
00821     p
("texte") ;
00822     echo "Lorsqu'on fournit entre crochets pour une variable de type vecteur un vecteur de m&ecirc;me longueur que cette variable compos&eacute; de  0 et de 1, " 
;
00823     echo 
$R extrait les valeurs correspondant &agrave; 1. Par exemple ".b("(1:3)[&nbsp;c(0,1,0)&nbsp;]")." renvoie ".b("2").". " ;
00824     echo " Comme nous avons expliqu&eacute; que les valeurs logiques FALSE et TRUE valent num&eacute;riquement 0 et 1, il est facile de comprendre que " 
;
00825     echo 
$R fournit un m&eacute;canisme de ".b("filtrage")." tr&egrave;s puissant avec les expressions logiques vectorielles. " ;
00826     finp
() ;
00827     
00828     p
("texte") ;
00829     #echo " En mode vectoriel, il faut utiliser ".b("&amp;&amp;")." et ".b("||")." pour effectuer des ET et des OU. " ;
00830     echo 
" Voici des exemples&nbsp;:" ;
00831     finp
() ;
00832     
00833     pre_fichier
("tests6.txt","cadre") ;
00834     
00835     finblockquote
() ;
00836     
00837     #######################################################################################################################
00838     
00839     $tdmCRLM3
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  Applications aux matrices et dataframes
00840     
00841     ## -------------------------------------------------------------------------------------------
00842     
00843     blockquote
() ;
00844     
00845     p
("texte") ;
00846     echo "En plus des vecteurs, 
$R dispose de deux structures de donn&eacute;es nomm&eacute;es " ;
00847     echo b
("matrix")." et ".b("data frame")." qui d&eacute;finissent des ".bleu("tableaux rectangulaires"). " avec des " ;
00848     echo vert
("lignes")." et des ".vert("colonnes").". Il y a toutefois des grandes diff&eacute;rences entre ces deux structures. " ;
00849     echo " Les matrices sont homog&egrave;nes en type et les lignes et les colonnes y sont &eacute;quivalentes en fonctionnement alors que les " 
;
00850     echo " data frames sont des listes particuli&egrave;res&nbsp;: les &eacute;l&eacute;ments de la liste sont les colonnes du tableau, avec la contrainte " 
;
00851     echo " que toutes les colonnes doivent avoir le m&ecirc;me nombre d'&eacute;l&eacute;ments. Un data frame est donc particuli&egrave;rement adapt&eacute; " 
;
00852     echo " &agrave; contenir un fichier de donn&eacute;es pour des &eacute;tudes statistiques, avec des colonnes de types &eacute;ventuellement diff&eacute;rents. " 
;
00853     finp
() ;
00854     
00855     p
("texte") ;
00856     echo " Toutes les " 
;
00857     echo " fonctions de 
$R qui lisent des fichiers comme " ;
00858     echo lafonction
("read.table","utils").", ";
00859     echo lafonction
("read.xls","gdata")." (du package ".hrrp("gdata").") " ;
00860     echo " renvoient des data frames." 
;
00861     finp
() ;
00862     
00863     p
("texte") ;
00864     echo "Les conditions logiques et le filtrage vectoriel permettent d'extraire facilement des sous-ensembles de ces tableaux " 
;
00865     echo " de donn&eacute;es comme le montrent les exemples ci-dessous" 
;
00866     echo " pour le fichier de donn&eacute;es "
.href("elf.txt")."&nbsp;:" ;
00867     finp
() ;
00868     
00869     pre_fichier
("extr.txt","cadre") ;
00870     
00871     finblockquote
() ;
00872     
00873     #######################################################################################################################
00874     
00875     $tdmCRLM3
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  Sp&eacute;cificit&eacute;s du langage $R
00876     
00877     ## -------------------------------------------------------------------------------------------
00878     
00879     blockquote
() ;
00880     
00881     p
("texte") ;
00882     echo "En 
$R, les indices commencent &agrave; 1. C'est une r&eacute;volution par rapport aux autres langages de programmation " ;
00883     echo " qui ne comptent pas en position mais en d&eacute;calage ("
.em("offset").") &agrave; partir du d&eacute;but du tableau. Cela facilite " ;
00884     echo " beaucoup les calculs. " 
;
00885     finp
() ;
00886     
00887     p
("texte") ;
00888     echo "A cause de la valeur NA -- qui est sp&eacute;cifique &agrave; R, la comparaison entre valeurs en 
$R est compliqu&eacute;e&nbsp;: " ;
00889     finp
() ;
00890     
00891     pre_fichier
("natables.txt","cadre") ;
00892     
00893     p
("texte") ;
00894     echo "Heureusement il y a de nombreuses fonctions comme " 
;
00895     echo hrrr
("NA","","is.na()") ;
00896     echo " et " 
;
00897     echo hrrr
("na.fail","stats","na.omit()") ;
00898     echo " qui permettent de d&eacute;tecter et d'enlever ces valeurs NA. On trouve aussi, comme pour " 
;
00899     echo lafonction
("sum").", une option ".b("na.rm=TRUE")." qui enl&egrave;ve (localement) ces valeurs NA." ;
00900     finp
() ;
00901     
00902     p
("texte") ;
00903     echo "
$R dispose de nombreuses fonctions logiques&nbsp;:" ;
00904     finp
() ;
00905     
00906     pre_fichier
("is.txt","cadre") ;
00907     
00908     p
("texte") ;
00909     echo "Comme nous l'avons dit pr&eacute;c&eacute;demment, les structures de donn&eacute;es de base sont les vecteurs et les listes. Il faut " 
;
00910     echo " n&eacute;anmoins bien connaitre les data frames et les matrices (et leurs \"pi&egrave;ges\") pour &eacute;crire de " 
;
00911     echo " \"beaux\" programmes concis&nbsp;:" 
;
00912     finp
() ;
00913     
00914     pre_fichier
("isdf.txt","cadre") ;
00915     
00916     
00917     p
("texte") ;
00918     echo "Il faut noter que 
$R permet d'affecter des parties de vecteur gr&acirc;ce &agrave; l'indexation et au filtrage logique. " ;
00919     echo " Ainsi l'instruction&nbsp;:" 
;
00920     finp
() ;
00921     
00922     pre_fichier
("remp.txt","cadre") ;
00923     
00924     
00925     p
("texte") ;
00926     echo " vient remplacer dans "
.("v")." toutes les valeurs strictements inf&eacute;rieures &agrave; 5 par 0." ;
00927     finp
() ;
00928     
00929     p
("texte") ;
00930     echo "Enfin, il existe sous 
$R plusieurs fonctions qui &eacute;vitent de faire des tests logiques pour trouver des " ;
00931     echo " valeurs, les remplacer... comme les fonctions " 
;
00932     echo hrrr
("ifelse").", " ;
00933     echo hrrr
("which").", " ;
00934     echo hrrr
("grep").", " ;
00935     echo hrrr
("grep","base","sub()")."... " ;
00936     finp
() ;
00937     
00938     #pre_fichier("grepwhich.txt","cadre") ;
00939     
00940     finblockquote
() ;
00941     
00942     #######################################################################################################################
00943     #
00944     # progic4
00945     #
00946     #######################################################################################################################
00947     
00948     $numcours 
partie($numcours) ; pvide() ;
00949     $rubrique  
;
00950     $rubriques4 
= array() ;
00951     $rubrique
++ ; $rubriques4[$rubrique] = "Boucles \"TANT QUE\"" ;
00952     $rubrique
++ ; $rubriques4[$rubrique] = "Boucles \"POUR\"" ;
00953     $rubrique
++ ; $rubriques4[$rubrique] = "Boucles \"REPETER JUSQU'A\"" ;
00954     $rubrique
++ ; $rubriques4[$rubrique] = "It&eacute;rations et sorties de boucles" ;
00955     $rubrique
++ ; $rubriques4[$rubrique] = "Imbrications, it&eacute;rations et sorties de boucles" ;
00956     $rubrique
++ ; $rubriques4[$rubrique] = "Exemples de boucles usuelles (mais potentiellement lentes) en $R";
00957     $rubrique
++ ; $rubriques4[$rubrique] = "Comment et pourquoi &eacute;viter les boucles pour en $R";
00958     $rubrique
++ ; $rubriques4[$rubrique] = "Sp&eacute;cificit&eacute;s du langage $R";
00959     
00960     $tdmCRLM4 
= new tdm($rubriques4) ;
00961     $tdmCRLM4
->titre() ;
00962     $tdmCRLM4
->menu("oui","oui","nou","p$numcours") ;
00963     
00964     $numRub 
;
00965     
00966     #######################################################################################################################
00967     
00968     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Boucles "tant que"
00969     
00970     ## -------------------------------------------------------------------------------------------
00971     
00972     blockquote
() ;
00973     
00974     p
("texte") ;
00975     echo "La boucle TANT QUE ("
.b("while")." en anglais) est un peu comme une structure ".b("si")." r&eacute;p&eacute;titive. ";
00976     echo " Sa syntaxe algorithmique est la suivante&nbsp;:" 
;
00977     finp
() ;
00978     
00979     pre_fichier
("tantque1a.txt","cadre") ;
00980     
00981     p
("texte") ;
00982     echo "Son &eacute;criture en 
$R est imm&eacute;diate&nbsp;:" ;
00983     finp
() ;
00984     
00985     pre_fichier
("tantque1b.txt","cadre") ;
00986     
00987     p
("texte") ;
00988     echo "En voici un exemple&nbsp;:" 
;
00989     finp
() ;
00990     
00991     pre_fichier
("tantque1c.txt","cadre") ;
00992     
00993     p
("texte") ;
00994     echo "Il faut &ecirc;tre "
.rouge("tr&egrave;s prudent(e)")." avec une boucle ".b("tant que")." car l'ordinateur " ;
00995     echo " peut boucler pendant un temps infini si la condition est mal &eacute;crite. Ainsi dans l'exemple " 
;
00996     echo " pr&eacute;c&eacute;dent, nous avons malheureusement oubli&eacute; que la machine ne doit pas aller apr&egrave;s le dernier caract&egrave;re. Supposer " 
;
00997     echo " qu'un nom de fichier contient toujours un point serait une erreur de conception et le code pr&eacute;c&eacute;dent ne s'arr&ecirc;te " 
;
00998     echo " jamais s'il n'y a pas de point dans le nom de fichier. Voici ce qu'il faut &eacute;crire pour avoir un code correct&nbsp;:" 
;
00999     finp
() ;
01000     
01001     pre_fichier
("tantque2.txt","cadre") ;
01002     # on peut en sortir avec break
01003     
01004     finblockquote
() ;
01005     
01006     #######################################################################################################################
01007     
01008     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Boucles "pour"
01009     
01010     ## -------------------------------------------------------------------------------------------
01011     
01012     blockquote
() ;
01013     
01014     p
("texte") ;
01015     echo "Lorsque le nombre de r&eacute;p&eacute;titions est connu, que ce soit une valeur constante comme 10 ou le nombre des &eacute;l&eacute;ments d'un vecteur, " 
;
01016     echo " on peut utiliser une autre structure r&eacute;p&eacute;titive, nomm&eacute;e boucle POUR dont voici la syntaxe algorithmique&nbsp;:" 
;
01017     finp
() ;
01018     
01019     pre_fichier
("pour1a.txt","cadre") ;
01020     
01021     p
("texte") ;
01022     echo "L&agrave; encore, son &eacute;criture en 
$R est imm&eacute;diate&nbsp;:" ;
01023     finp
() ;
01024     
01025     pre_fichier
("pour1b.txt","cadre") ;
01026     
01027     p
("texte") ;
01028     echo "Et un exemple peut &ecirc;tre&nbsp;:" 
;
01029     finp
() ;
01030     
01031     pre_fichier
("pour1c.txt","cadre") ;
01032     
01033     p
("texte") ;
01034     echo "Dans les faits, 
$R dispose d'une boucle POUR plus g&eacute;n&eacute;rale d'it&eacute;ration nomm&eacute;e aussi ".b("for").". Voici des  " ;
01035     echo " exemples&nbsp;:" 
;
01036     finp
() ;
01037     
01038     pre_fichier
("pour2.txt","cadre") ;
01039     
01040     finblockquote
() ;
01041     
01042     #######################################################################################################################
01043     
01044     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Boucles "REPETER JUSQU'A"
01045     
01046     ## -------------------------------------------------------------------------------------------
01047     
01048     blockquote
() ;
01049     
01050     p
("texte") ;
01051     echo "Le troisi&egrave;me type de boucle disponible consiste &agrave; faire le test pour savoir \n" 
;
01052     echo "si on recommence la boucle "
.b("en fin de corps de boucle").". La syntaxe \n" ;
01053     echo "algorithmique est la suivante&nbsp;: \n" 
;
01054     finp
() ;
01055     
01056     pre_fichier
("repeter1.txt","cadre") ;
01057     
01058     p
("texte") ;
01059     echo "Sa traduction n'est pas imm&eacute;diate en 
$R parce qu'on &eacute;crit seulement \n" ;
01060     finp
() ;
01061     
01062     pre_fichier
("repeter2.r","cadre") ;
01063     
01064     p
("texte") ;
01065     echo "Il faut imp&eacute;rativement passer par "
.noir("break")." ou ".noir("stop()")." pour sortir de la boucle \n" ;
01066     echo " REPETER JUSQU'A en 
$R. \n" ;
01067     echo "Voici un exemple d'une telle boucle en 
$R qui demande un nom de fichier et teste si le \n" ;
01068     echo "fichier est pr&eacute;sent avant d'aller plus loin&nbsp;: \n" 
;
01069     finp
() ;
01070     
01071     pre_fichier
("repeter3.r","cadre") ;
01072     
01073     p
("texte") ;
01074     echo rouge
("Attention&nbsp;: ") ;
01075     echo " il y beaucoup de fonctions 
$R qui dispensent d'&eacute;crire des boucles. Il est prudent de " ;
01076     echo " les apprendre parce que l'ex&eacute;cution des boucles en 
$R " ;
01077     echo " est souvent lente &agrave; cause de la gestion en m&eacute;moire des variables. " 
;
01078     echo " Ainsi "
.lafonction("cbind")." fournit nativement la correspondance  entre indice et &eacute;l&eacute;ment. " ;
01079     #echo " Voir les exercices pour se convaincre qu'il faut apprendre de nombreuses fonctions $R." ;
01080     finp
() ;
01081     
01082     finblockquote
() ;
01083     
01084     #######################################################################################################################
01085     
01086     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # It&eacute;rations et sorties de boucles
01087     
01088     ## -------------------------------------------------------------------------------------------
01089     
01090     blockquote
() ;
01091     
01092     p
("texte") ;
01093     echo "Il peut arriver que l'on veuille sortir d'une boucle ou du script. " 
;
01094     echo " Quelque soit le type de boucle, " 
;
01095     echo " la fonction "
.hrrr("stop")." quitte le script en cours alors que l'instruction " ;
01096     echo b
("break")." permet de sortir de la boucle. On peut aussi utiliser ".b("next")." pour " ;
01097     echo " forcer la machine &agrave; passer &agrave; l'it&eacute;ration suivante. " 
;
01098     echo " Voici des exemples&nbsp;:" 
;
01099     finp
() ;
01100     
01101     pre_fichier
("boucles3.ent","cadrebleu") ;
01102     
01103     p
("texte") ;
01104     echo "L'ex&eacute;cution de cette boucle aboutit aux r&eacute;sultats suivants&nbsp;:" 
;
01105     finp
() ;
01106     
01107     pre_fichier
("boucles3.sor","cadrejaune") ;
01108     
01109     finblockquote
() ;
01110     
01111     #######################################################################################################################
01112     
01113     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Imbrications, it&eacute;rations et sorties de boucles
01114     
01115     ## -------------------------------------------------------------------------------------------
01116     
01117     blockquote
() ;
01118     
01119     p
("texte") ;
01120     echo "Comme pour les tests, on peut imbriquer les boucles, &eacute;ventuellement de diff&eacute;rents \n" 
;
01121     echo "types. De plus, un corps de boucle contient des instructions, donc on peut avoir \n" 
;
01122     echo "une boucle &agrave; l'int&eacute;rieur de la partie \"sinon\" d'un test, qui contient elle-m&ecirc;me \n" 
;
01123     echo "un autre test avec une autre boucle, etc. \n" 
;
01124     finp
() ;
01125     
01126     p
("texte") ;
01127     echo "On veillera &agrave; ne pas trop multiplier l'imbrication des structures de fa&ccedil;on &agrave; pouvoir \n" 
;
01128     echo "s'y retrouver facilement. Trois ou quatre niveaux d'imbrication (une boucle dans un \n" 
;
01129     echo "test dans une boucle dans...) parait &ecirc;tre la "
.em("limite supportable de la compr&eacute;hension").". \n" ;
01130     echo "Au-del&agrave;, il faut certainement recourir &agrave; un sous-programme (une fonction) pour que ce soit lisible... \n" 
;
01131     finp
() ;
01132     
01133     p
("texte") ;
01134     echo "Voici des exemples avec chacun des types de boucles qui illustrent ces points. \n" 
;
01135     finp
() ;
01136     
01137     p
("texte") ;
01138     echo "Nous commen&ccedil;ons avec deux boucles "
.b("POUR")."  imbriqu&eacute;es pour afficher les valeurs \n" ;
01139     echo "de "
.b("x^y")." inf&eacute;rieures &agrave; 1 million pour les nombres ".b("x")." et ".b("y")." de 1 &agrave; 10. \n" ;
01140     echo "On affiche les puissances de 1, de 2, de 3... ligne par ligne. Pour &eacute;viter de calculer \n" 
;
01141     echo "math&eacute;matiquement jusqu'&agrave; quel terme on doit aller, on calcule la puissance et \n" 
;
01142     echo "on ne l'affiche que si elle est inf&eacute;rieure &agrave; un million. \n" 
;
01143     finp
() ;
01144     
01145     p
("texte") ;
01146     echo "Voici le code 
$R  correspondant&nbsp;:\n" ;
01147     finp
() ;
01148     
01149     pre_fichier
("boucles3a.ent","cadre") ;
01150     
01151     p
("texte") ;
01152     echo "et le r&eacute;sultat de son ex&eacute;cution \n" 
;
01153     finp
() ;
01154     
01155     pre_fichier
("boucles3a.sor","cadre") ;
01156     
01157     p
("texte") ;
01158     echo "Le deuxi&egrave;me exemple montre comment tester une fonction &agrave; l'aide d'une r&eacute;ponse utilisateur \n" 
;
01159     echo "via une boucle "
.b("REPETER")." . \n" ;
01160     echo "Ici, nous avons pris l'exemple de la fonction qui calcule le carr&eacute; pour des raisons de simplicit&eacute;. \n" 
;
01161     finp
() ;
01162     
01163     p
("texte") ;
01164     echo "L'id&eacute;e est ici de demander une valeur &agrave; l'utilisateur, d'afficher le r&eacute;sultat de la fonction et \n" 
;
01165     echo "de recommencer. Nous avons d&eacute;cid&eacute; arbitrairement qu'entrer la valeur z&eacute;ro fait sortir de la boucle. \n" 
;
01166     finp
() ;
01167     
01168     pre_fichier
("boucles3b.ent","cadre") ;
01169     
01170     p
("texte") ;
01171     echo "L'ex&eacute;cution de cette boucle aboutit aux r&eacute;sultats suivants, \n" 
;
01172     echo "sachant que l'utilisateur a saisi 5, puis 8 puis 0 (afin d'arr&ecirc;ter le calcul). \n" 
;
01173     finp
() ;
01174     
01175     pre_fichier
("boucles3b.sor","cadre") ;
01176     
01177     p
("texte") ;
01178     echo "Comme troisi&egrave;me exemple, nous essayons de traiter avec une boucle "
.b("TANT QUE").".  \n" ;
01179     echo "tous les fichiers-texte du r&eacute;pertoire avec une num&eacute;rotation r&eacute;guli&egrave;re \n" 
;
01180     echo "lorsqu'ils ont plus de deux lignes&nbsp;: \n" 
;
01181     finp
() ;
01182     
01183     pre_fichier
("boucles3c.ent","cadre") ;
01184     
01185     p
("texte") ;
01186     echo "Un exemple d'&eacute;x&eacute;cution, avec quelques fichiers pr&eacute;sents dans notre r&eacute;pertoire courant \n" 
;
01187     echo "fournit l'affichage suivant. On remarquera que 
$R  &eacute;crit ".b("Erreur")." lorsqu'on fait appel \n" ;
01188     echo "&agrave; la fonction "
.noir("stop()")." . \n" ;
01189     finp
() ;
01190     
01191     pre_fichier
("boucles3c.sor","cadre") ;
01192     
01193     finblockquote
() ;
01194     
01195     #######################################################################################################################
01196     
01197     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Exemples de boucles usuelles (mais lentes) en $R
01198     
01199     ## -------------------------------------------------------------------------------------------
01200     
01201     blockquote
() ;
01202     
01203     p
("texte") ;
01204     echo "Nous pr&eacute;sentons ici quelques boucles "
.em("faussement susceptibles d'&ecirc;tre utiles").". \n" ;
01205     echo "En effet, la plupart de ces boucles explicites peuvent &ecirc;tre remplac&eacute;es &agrave; moindre \n" 
;
01206     echo "co&ucirc;t d'&eacute;criture par des fonctions de 
$R  pr&eacute;vues pour cela. Ces exemples ne sont donc \n" ;
01207     echo "fournis qu'&agrave; titre d'entrainement &agrave; la lecture de boucles et ne sont pas optimis&eacute;s. \n" 
;
01208     finp
() ;
01209     
01210     p
("texte") ;
01211     echo "Nous aurons l'occasion de revoir un peu plus tard comment r&eacute;aliser les traitements associ&eacute;s &agrave; ces boucles \n" 
;
01212     echo "de fa&ccedil;on beaucoup plus \"propre et concise\" et, en tous cas, dans l'esprit de 
$R. \n" ;
01213     finp
() ;
01214     
01215     h3
("$numRub.1 Traitement de toutes les colonnes d'un ".em("data frame")) ;
01216     
01217     p
("texte") ;
01218     echo "Il arrive assez fr&eacute;quemment qu'on ait &agrave; traiter toutes les colonnes num&eacute;riques quantitatives d'un data frame, \n" 
;
01219     echo "par exemple pour en calculer syst&eacute;matiquement les moyennes, les m&eacute;dianes (au fait, vous vous souvenez \n" 
;
01220     echo "de la diff&eacute;rence statistique entre \n" 
;
01221     echo "ces deux indicateurs de tendance centrale et pourquoi on calcule la moyenne des tailles, la m&eacute;diane des poids pour les humains et \n" 
;
01222     echo "pas l'inverse&nbsp;?)... \n" 
;
01223     finp
() ;
01224     
01225     p
("texte") ;
01226     echo "
$R  fournit avec la fonction ".hrrr("nrow","","ncol()")." le nombre de colonnes d'un data frame et \n" ;
01227     echo "avec la fonction "
.hrrr("names")." le nom de ces colonnes. Il pourrait &ecirc;tre tentant d'&eacute;crire une boucle comme \n" ;
01228     finp
() ;
01229     
01230     pre_fichier
("noallqt.r","cadre") ;
01231     
01232     p
("texte") ;
01233     echo "mais c'est certainement se fatiguer beaucoup, surtout si le num&eacute;ro de colonne n'est pas utilis&eacute;. Il est possible \n" 
;
01234     echo "en 
$R  de passer directement en revue les noms de colonne. Au passage, nous montrons comment construire un fichier graphique \n" ;
01235     echo "de type "
.noir(".png")." dont le nom reprend celui de la colonne en cours, apr&egrave;s d&eacute;tection du type num&eacute;rique de \n" ;
01236     echo "la colonne&nbsp;: \n" 
;
01237     finp
() ;
01238     
01239     pre_fichier
("allqt.r","cadre") ;
01240     
01241     h3
("$numRub.2 Calculs par sous-groupe") ;
01242     
01243     p
("texte") ;
01244     echo "Imaginons maintenant que nous voulions parcourir toutes les lignes d'un data frame pour compter (maladroitement) \n" 
;
01245     echo "via le code-sexe (variable "
.noir("SX").") \n" ;
01246     echo "le nombre d'hommes ("
.noir("SX=1").") et de femmes (".noir("SX=2")."). De fa&ccedil;on encore plus maladroite, nous allons \n" ;
01247     echo "mettre dans la variable "
.noir("agesH")." les ages des hommes \n" ;
01248     echo "et dans la variable "
.noir("agesF")." les ages des femmes. ".s_span("Voici ce qu'il ne faut pas faire","grouge").", mais au moins, vous \n" ;
01249     echo "l'aurez vu et vous saurez l'&eacute;viter&nbsp;: \n" 
;
01250     finp
() ;
01251     
01252     pre_fichier
("pargroupes.r","cadre") ;
01253     
01254     h3
("$numRub.3 Traitement d'une liste de fichiers et moyenne dans un tableau") ;
01255     
01256     p
("texte") ;
01257     echo "On veut traiter "
.b("n")." fichiers, disons " ;
01258     echo href
("ficSerie01.txt").", " ;
01259     echo href
("ficSerie02.txt").", " ;
01260     echo href
("ficSerie03.txt")."... " ;
01261     echo " mais ce pourrait &ecirc;tre bien s&ucirc;r des fichiers Excel." 
;
01262     echo " Une fois le traitement de chaque fichier effectu&eacute;, on veut obtenir un tableau et un fichier .CSV r&eacute;sum&eacute; des traitements. " 
;
01263     finp
() ;
01264     
01265     p
("texte") ;
01266     echo  "Pour notre exemple, nous allons limiter le traitement, via la fonction "
.b("traiteFichier()")." &agrave; la d&eacute;termination du nombre " ;
01267     echo " de lignes du fichier. Voici cette fonction&nbsp;:" 
;
01268     finp
() ;
01269     
01270     pre_fichier
("seriefic01.r","cadre") ;
01271     
01272     p
("texte") ;
01273     echo  "Une fois la fonction "
.b("traiteFichier()")." mise au point, on peut &eacute;crire -- m&ecirc;me si ce n'est pas la seule et la " ;
01274     echo " meilleure solution -- une boucle pour passer en revue une s&eacute;rie de fichiers&nbsp;:" 
;
01275     finp
() ;
01276     
01277     pre_fichier
("seriefic02.r","cadre") ;
01278     
01279     p
("texte") ;
01280     echo  "Afin d'obtenir un tableau r&eacute;sum&eacute;, il faut pr&eacute;voir un "
.em("data.frame")." pour accueillir les r&eacute;sultats " ;
01281     echo " et modifier la fonction "
.b("traiteFichier()")." pour qu'elle renvoie un r&eacute;sultat par fichier. On remplit " ;
01282     echo " alors au fur et &agrave; mesure la structure d'accueil dans la boucle. Une fois la boucle termin&eacute;e, on peut " 
;
01283     echo " afficher les r&eacute;sultats et les sauvegarder." 
;
01284     finp
() ;
01285     
01286     p
("texte") ;
01287     echo " Voici la fonction modifi&eacute;e&nbsp;:" 
;
01288     finp
() ;
01289     
01290     pre_fichier
("seriefic03.r","cadre") ;
01291     
01292     p
("texte") ;
01293     echo " Le script qui comporte la boucle et la gestion du "
.em("data.frame")." est le suivant&nbsp;:" ;
01294     finp
() ;
01295     
01296     pre_fichier
("seriefic04.r","cadre") ;
01297     
01298     p
("texte") ;
01299     echo " Exemple d'ex&eacute;cution avec les fichiers cit&eacute;s&nbsp;:" 
;
01300     finp
() ;
01301     
01302     pre_fichier
("seriefic04.sor","cadre") ;
01303     
01304     p
("texte") ;
01305     echo " Fichier CSV produit&nbsp;:" 
;
01306     finp
() ;
01307     
01308     pre_fichier
("seriefic04.csv","cadre") ;
01309     
01310     finblockquote
() ;
01311     
01312     #######################################################################################################################
01313     
01314     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Comment et pourquoi &eacute;viter les boucles pour en R
01315     
01316     ## -------------------------------------------------------------------------------------------
01317     
01318     blockquote
() ;
01319     
01320     /*
01321     p("texte") ;
01322     echo "Les boucles, et en particulier les boucles POUR, sont souvent le moyen de r&eacute;aliser des calculs " ;
01323     echo " par it&eacute;ration dans les langages de programmation \"classiques\". ".b("CE N'EST PAS LE CAS EN $R")." parce que " ;
01324     echo " $R est un langage ".rouge("vectoriel").".  De nombreuses fonctions s'appliquent directement " ;
01325     echo " aux vecteurs, comme ".hrrr("sum")."&nbsp;; pour les matrices et les listes, il faut utiliser " ;
01326     echo hrrr("apply")." et ".hrrr("lapply","","sapply").". Et il y a beaucoup d'autres fonctions pr&eacute;vues pour couvrir " ;
01327     echo " de nombreux autres cas, comme ".hrrr("tapply")."..." ;
01328     finp() ;
01329     */
01330     
01331     p
("texte") ;
01332     echo "Les boucles, et en particulier les boucles "
.b("POUR").", sont souvent \n" ;
01333     echo "le moyen de r&eacute;aliser des calculs par it&eacute;ration dans les langages \n" 
;
01334     echo "de programmation \"classiques\". \n" 
;
01335     finp
() ;
01336     
01337     p
("texte") ;
01338     echo rouge
("CE N'EST PAS LE CAS EN $R")." parce que \n" ;
01339     echo "
$R  est un langage vectoriel. De nombreuses fonctions s'appliquent \n" ;
01340     echo "directement aux vecteurs, comme "
.hrrr("sum")."&nbsp;; pour les matrices et les \n" ;
01341     echo "listes, il faut utiliser des fonctions comme "
.hrrr("apply").", ".hrrr("lapply").", ".hrrr("lapply","","sapply()")." \n" ;
01342     echo "et "
.hrrr("tapply")."... Et il y a beaucoup \n" ;
01343     echo "d'autres fonctions pr&eacute;vues pour couvrir de nombreux autres cas, \n" 
;
01344     echo "comme "
.hrrr("table").", ".hrrr("split").", ".hrrr("sweep")."... \n" ;
01345     echo " Nous verrons &agrave; la s&eacute;ance 6 comment on arrive &agrave; se passer des boucles et &agrave; la s&eacute;ance 8 comment " 
;
01346     echo " optimiser des boucles si on doit vraiment les utiliser." 
;
01347     finp
() ;
01348     
01349     finblockquote
() ;
01350     
01351     #######################################################################################################################
01352     
01353     $tdmCRLM4
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Sp&eacute;cificit&eacute;s du langage R
01354     
01355     ## -------------------------------------------------------------------------------------------
01356     
01357     blockquote
() ;
01358     
01359     p
("texte") ;
01360     echo "Une programmeuse, un programmeur C ou Java \"classique\" a l'habitude des \n" 
;
01361     echo "boucles "
.b("POUR")." d&egrave;s qu'il s'agit de parcourir une structure. \n" ;
01362     echo "En 
$R , il y a beaucoup d'autres solutions et il faut du temps pour les connaitre. \n" ;
01363     echo "Ainsi, et m&ecirc;me si ce n'est pas \"la\" bonne solution, pour obtenir la variable \n" 
;
01364     echo "pr&eacute;c&eacute;dente "
.noir("agesH")." qui contient les ages de hommes, on peut se contenter en \n" ;
01365     echo "
$R  d'utiliser le filtrage vectoriel et &eacute;crire \n" ;
01366     finp
() ;
01367     
01368     pre_fichier
("agesh1.r","cadre") ;
01369     
01370     p
("texte") ;
01371     echo "ou, de fa&ccedil;on plus lisible&nbsp;: \n" 
;
01372     finp
() ;
01373     
01374     pre_fichier
("agesh2.r","cadre") ;
01375     
01376     p
("texte") ;
01377     echo "Il est clair qu'on est loin de l'&eacute;criture d'une boucle explicite. \n" 
;
01378     finp
() ;
01379     
01380     p
("texte") ;
01381     echo "M&ecirc;me lorsqu'on veut utiliser des boucles "
.b("POUR")." en $R  il faut se m&eacute;fier. \n" ;
01382     echo "Ainsi l'expression "
.noir("for (i in 1:length(V))")." n'est pas une \"bonne\" &eacute;criture. En effet, si le \n" ;
01383     echo "vecteur "
.noir("V")." est vide, sa longueur est nulle. Dans un langage classique, une boucle \n" ;
01384     echo "de 1 &agrave; 0 n'est pas ex&eacute;cut&eacute;e. Pour 
$R, la notation ".noir("1:0")." signifie qu'on veut aller \n" ;
01385     echo "de 1 &agrave; 0 et il ex&eacute;cutera la boucle&nbsp;! Ce qui est pire, c'est que "
.noir("V[i]")." ne renverra pas \n" ;
01386     echo "alors forc&eacute;ment d'erreur lorsque "
.noir("i")." vaut 0. Il est donc conseill&eacute; d'utiliser \n" ;
01387     echo ""
.noir("for&nbsp;(i&nbsp;in&nbsp;seq_along(V))")." pour parcourir les indices de ".noir("V")." car si  ".noir("V")." est vide, \n" ;
01388     echo "
$R  ne rentrera pas dans la boucle avec cette &eacute;criture. \n" ;
01389     finp
() ;
01390     
01391     finblockquote
() ;
01392     
01393     #######################################################################################################################
01394     #
01395     # progic5
01396     #
01397     #######################################################################################################################
01398     
01399     $numcours 
partie($numcours) ; pvide() ;
01400     $rubrique  
;
01401     $rubriques5 
= array() ;
01402     $rubrique
++ ; $rubriques5[$rubrique] = "D&eacute;finition des fonctions nomm&eacute;es et anonymes" ;
01403     $rubrique
++ ; $rubriques5[$rubrique] = "D&eacute;finition et utilisation des param&egrave;tres" ;
01404     $rubrique
++ ; $rubriques5[$rubrique] = "Tests des param&egrave;tres" ;
01405     $rubrique
++ ; $rubriques5[$rubrique] = "L'ellipse not&eacute;e ".rouge("...") ;
01406     $rubrique
++ ; $rubriques5[$rubrique] = "Quelques exemples de fonctions" ;
01407     $rubrique
++ ; $rubriques5[$rubrique] = "Sp&eacute;cificit&eacute;s du langage $R";
01408     
01409     $tdmCRLM5 
= new tdm($rubriques5) ;
01410     $tdmCRLM5
->titre() ;
01411     $tdmCRLM5
->menu("oui","oui","nou","p$numcours") ;
01412     
01413     $numRub 
;
01414     
01415     #######################################################################################################################
01416     
01417     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # D&eacute;finition d'une fonction
01418     
01419     ## -------------------------------------------------------------------------------------------
01420     
01421     blockquote
() ;
01422     
01423     p
("texte") ;
01424       echo "Pour d&eacute;finir une "
.bleu("fonction nomm&eacute;e").", il faut r&eacute;aliser une affectation avec comme partie gauche le nom de la fonction &agrave; cr&eacute;er, " ;
01425       echo " puis utiliser le mot "
.b("function").", mettre des parenth&egrave;ses, " ;
01426       echo " ajouter des param&egrave;tres s'il y en a besoin avec &eacute;ventuellement des valeurs par d&eacute;faut, puis &eacute;crire le corps de la fonction " 
;
01427       echo " entre accolades et mettre "
.b("return")." avec des parenth&egrave;ses pour indiquer l'objet renvoy&eacute;, qui peut &ecirc;tre une simple valeur " ;
01428       echo " ou quelque chose de plus complexe. Par exemple, pour inventer une fonction qui calcule le carr&eacute; d'une valeur, on devrait &eacute;crire " 
;
01429     finp
() ;
01430     
01431     entree_R
("carre1.r") ;
01432     
01433     p
("texte") ;
01434       echo "Il est possible de raccourcir le corps de la fonction en " 
;
01435       echo " omettant les accolades et en mettant comme derni&egrave;re (ou comme seule) instruction le calcul &agrave; renvoyer. Ainsi, on pourrait &eacute;crire " 
;
01436     finp
() ;
01437     
01438     entree_R
("carre2.r") ;
01439     
01440     p
("texte") ;
01441       echo "Une &eacute;criture aussi concise est utile dans le cas d'une fonction int&eacute;gr&eacute;e &agrave; un appel de fonction " 
;
01442       echo " ou pour une "
.bleu("fonction anonyme")." (concept d&eacute;taill&eacute; un peu plus bas dans cette section), mais cette " ;
01443       echo " &eacute;criture est dangereuse et &laquo;fain&eacute;ante&raquo;. Il vaut mieux lui pr&eacute;f&eacute;rer le code suivant : " 
;
01444     finp
() ;
01445     
01446     entree_R
("carre3.r") ;
01447     
01448     p
("texte") ;
01449       echo "Nous reviendrons sur ces &eacute;critures, mais un grand principe de la "
.b("programmation robuste")." est qu'il faut pr&eacute;f&eacute;rer la " ;
01450       echo rouge
("lisibilit&eacute;").", la ".rouge("facilit&eacute; de relecture")." et la " ;
01451       echo rouge
("maintenance du code")." &agrave; la facilit&eacute; d'&eacute;criture. Il faut viser l'&eacute;criture de programmes " ;
01452       echo bleu
("robustes")." et ".bleu("lisibles")." et non pas de programmes vite tap&eacute;s sur le clavier. " ;
01453     finp
() ;
01454     
01455     p
("texte") ;
01456       echo "Pour se servir de cette fonction "
.bleu("carre()")." il suffit de l'appeler l&agrave; o&ugrave; on utiliserait le carr&eacute; des valeurs. Cela peut donc &ecirc;tre " ;
01457       echo " dans le cadre d'un calcul simple ou d'un affichage interactif (en console), dans le cadre d'une instruction d'affectation etc. " 
;
01458       echo " Il n'est pas obligatoire " 
;
01459       echo " ici de nommer le param&egrave;tre au niveau de l'appel, mais il vaudra mieux le faire quand il y en aura plus d'un. On peut aussi utiliser juste le nom " 
;
01460       echo " de la fonction en tant que param&egrave;tre quand cela est permis. Le calcul effectu&eacute; par notre fonction &eacute;tant \"vectoriel\", c'est-&agrave;-dire  " 
;
01461       echo " applicable &agrave; une structure, notre fonction est elle-m&ecirc;me vectorielle. Voici des exemples d'utilisation : " 
;
01462     finp
() ;
01463     
01464     entree_R
("carre4.r") ;
01465     p
("texte") ;
01466       echo "Et leurs r&eacute;sultats : " 
;
01467     finp
() ;
01468     sortie_R
("carre4.res") ;
01469     
01470     p
("texte") ;
01471       echo " Imaginons maintenant que nous voulions &eacute;crire une fonction " 
;
01472       echo "  "
.bleu("pvalt()")." qui doit renvoyer la ".em("p-value")." du ".b("test t")." de ".em("Student") ;
01473       echo " via l'appel de la fonction "
.hrrr("t.test","stats").". " ;
01474       echo " Il faut commencer par comprendre l'objet renvoy&eacute; par la fonction "
.hrrr("t.test","stats").", puis trouver comment extraire la composante " ;
01475       echo " voulue, pour ensuite &eacute;crire la fonction et enfin v&eacute;rifier qu'elle renvoie bien ce qu'on voulait&nbsp;:" 
;
01476     finp
() ;
01477     
01478     entree_R
("pval.r") ;
01479     sortie_R
("pval.res") ;
01480     
01481     p
("texte") ;
01482       echo "Une fonction anonyme correspond &agrave; la seule partie droite de d&eacute;finition de la fonction. Comme on l'utilise sans affectation, elle n'a pas de nom. " 
;
01483       echo " Une telle fonction s'utilise g&eacute;n&eacute;ralement comme param&egrave;tre dans un appel de fonction. " 
;
01484       echo " Ainsi, pour r&eacute;aliser le calcul de carr&eacute;s dans une liste, on peut &eacute;crire, sans passer par une fonction "
.b("carre()")."&nbsp;:" ;
01485     finp
() ;
01486     
01487     entree_R
("carre5.r") ;
01488     
01489     p
("texte") ;
01490       echo "Si on se rend compte qu'on utilise plusieurs fois la m&ecirc;me fonction anonyme, il est conseill&eacute; d'en faire une " 
;
01491       echo "fonction nomm&eacute;e. Cela gagne du temps et de la maintenance de code." 
;
01492     finp
() ;
01493     
01494     finblockquote
() ;
01495     
01496     #######################################################################################################################
01497     
01498     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  D&eacute;finition et utilisation des param&egrave;tres
01499     
01500     ## -------------------------------------------------------------------------------------------
01501     
01502     blockquote
() ;
01503     
01504     p
("texte") ;
01505       echo "Pour d&eacute;finir les param&egrave;tres d'une fonction, on doit imp&eacute;rativement les nommer. Par contre, il est " 
;
01506       echo " facultatif de leur donner une valeur par d&eacute;faut avec =. Mettre l'ellipse dans la d&eacute;finition des " 
;
01507       echo " param&egrave;tres signifie que la fonction peut accepter (et transmettre) d'autres param&egrave;tres que ceux " 
;
01508       echo " explicitement fournis. Voir la section 4 pour le d&eacute;tail sur l'ellipse. " 
;
01509     finp
() ;
01510     
01511     p
("texte") ;
01512     echo "Utiliser les param&egrave;tres dans un ordre ou dans un autre peut &ecirc;tre plus ou moins facile &agrave; m&eacute;moriser ou &agrave; " 
;
01513     echo " comprendre. On pourra s'en rendre compte si on compare les choix de l'ordre des param&egrave;tres pour le calcul de la somme des colonnes " 
;
01514     echo " d'une matrice via "
.lafonction("apply")." dans les codes $R suivants&nbsp;:" ;
01515     finp
() ;
01516     
01517     pre_fichier
("somcol3.txt","cadre") ;
01518     
01519     
01520     finblockquote
() ;
01521     
01522     #######################################################################################################################
01523     
01524     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Tests des param&egrave;tres
01525     
01526     ## -------------------------------------------------------------------------------------------
01527     
01528     blockquote
() ;
01529     
01530     p
("texte") ;
01531       echo " On peut tester si un param&egrave;tre est pr&eacute;sent (ou plut&ocirc;t absent) avec " 
;
01532       echo b
("missing(param&egrave;tre)").". La liste des param&egrave;tres est fournie par ".b("formals(fonction)")." mais on " ;
01533       echo " peut aussi utiliser "
.b("args(fonction)")." pour connaitre l'ent&ecirc;te de la fonction&nbsp;; le texte de la fonction est donn&eacute; par " ;
01534       echo "  "
.b("body(fonction)")."." ;
01535       echo " Voici quelques exemples qui montrent que 
$R est un langage assez ".b("ouvert")." puisqu'on peut consulter le code source du langage&nbsp;:" ;
01536     finp
() ;
01537     
01538     pre_fichier
("param1.txt","cadre") ;
01539     
01540     p
("texte") ;
01541     echo "Il est classique de tester le type (la classe des param&egrave;tres) avec une fonction "
.b("is.").vert("*") ;
01542     echo " et de quitter le programme avec "
.b("stop")." ou ".b("stopifnot").". " ;
01543     echo " Voici l&agrave; encore quelques exemples issus du propre code de 
$R&nbsp;:" ;
01544     finp
() ;
01545     
01546     pre_fichier
("param2.txt","cadre") ;
01547     
01548     finblockquote
() ;
01549     
01550     #######################################################################################################################
01551     
01552     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  L'ellipse not&eacute;e ...
01553     
01554     ## -------------------------------------------------------------------------------------------
01555     
01556     blockquote
() ;
01557     
01558     p
("texte") ;
01559     echo "Comme le montrent les exemples pr&eacute;c&eacute;dents, un argument possible pour une fonction est l'ellipse, qui se note " 
;
01560     echo rouge
("...")." (trois points qui se suivent) et dont l'aide est " ;
01561     echo hrrr
("dotsMethods","methods","ici").". " ;
01562     echo " Cette notation, qui se r&eacute;v&egrave;le tr&egrave;s pratique &agrave; l'usage, permet de ne pas sp&eacute;cifier tous les param&egrave;tres &agrave; utiliser " 
;
01563     echo " et de laisser le soin &agrave; 
$R de les transmettre. " ;
01564     echo " L'ellipse sert beaucoup lorsqu'on &eacute;crit une fonction de trac&eacute; graphique et pour impl&eacute;menter des fonctions g&eacute;n&eacute;riques. " 
;
01565     echo " Les param&egrave;tres qu'on d&eacute;finit sont les plus " 
;
01566     echo " usuels et l'ellipse permet de passer les moins fr&eacute;quents. " 
;
01567     finp
() ;
01568     
01569     p
("texte") ;
01570     echo "Imaginons par exemple que l'on veuille interfacer la fonction "
.hrrr("boxplot","graphics") ;
01571     echo " avec un titre et une unit&eacute; obligatoires. Voici la trame d'une " 
;
01572     echo " telle fonction&nbsp;:" 
;
01573     finp
() ;
01574     
01575     pre_fichier
("boxplot1.r","cadre") ;
01576     
01577     p
("texte") ;
01578     echo "Il est clair qu'avec une telle fonction on ne peut pas modifier les bornes "
.b("xlim")." et ".b("ylim") ;
01579     echo " du trac&eacute;, par exemple. Au lieu de les rajouter comme arguments, le mieux est d'ajouter l'ellipse. " 
;
01580     echo " D&egrave;s lors, l'utilisateur a acc&egrave;s &agrave; toutes les options de boxplot&nbsp;:" 
;
01581     finp
() ;
01582     
01583     pre_fichier
("boxplot2.r","cadre") ;
01584     
01585     finblockquote
() ;
01586     
01587     #######################################################################################################################
01588     
01589     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Quelques exemples de fonctions
01590     
01591     ## -------------------------------------------------------------------------------------------
01592     
01593     blockquote
() ;
01594     
01595     p
("texte") ;
01596     echo "Afin de vous entrainer &agrave; bien \"parler fonction en 
$R\", voici quatres exemples qui mettent en \n" ;
01597     echo "pratique tout ce que nous venons de d&eacute;crire. Nous montrerons au passage comment \"progresser\" \n" 
;
01598     echo "dans l'&eacute;criture d'une fonction. \n" 
;
01599     finp
() ;
01600     
01601     h2
("$numRub.1 La fonction moyenne()") ;
01602     
01603     p
("texte") ;
01604     echo "Pour impl&eacute;menter une fonction nomm&eacute;e "
.b("moyenne()")." -- aussi bizarre que cela puisse \n" ;
01605     echo "paraitre &agrave; une ou un n&eacute;ophyte, cette d&eacute;finition est plus rapide que la \"vraie\" fonction "
.hrrr("mean")."  \n" ;
01606     echo "de 
$R pour des petits vecteurs num&eacute;riques -- le code minimal est le suivant&nbsp;: \n" ;
01607     finp
() ;
01608     
01609     pre_fichier
("moyenne1.r","cadre") ;
01610     
01611     p
("texte") ;
01612     echo "Cet exemple de d&eacute;finition est suffisant dans l'environnement de 
$R, en mode interactif, si \n" ;
01613     echo "on est press&eacute; de tester la fonction. \n" 
;
01614     finp
() ;
01615     
01616     p
("texte") ;
01617     echo "Toutefois, il vaut mieux mettre un commentaire pour \n" 
;
01618     echo "d&eacute;tailler ce que fait la fonction et utiliser explicitement le mot "
.b("return()")." pour \n" ;
01619     echo "indiquer ce qui est renvoy&eacute;&nbsp;: \n" 
;
01620     finp
() ;
01621     
01622     pre_fichier
("moyenne2.r","cadre") ;
01623     
01624     p
("texte") ;
01625     echo "Apr&egrave;s r&eacute;flexion, vous pourrez vous rendre compte que l'argument de "
.b("moyenne()")." doit \n" ;
01626     echo "&ecirc;tre num&eacute;rique, car sinon la fonction "
.hrrr("sum")." &eacute;choue. De m&ecirc;me, s'il y a des ".b("NA")." \n" ;
01627     echo "dans les valeurs, la fonction "
.hrrr("sum")." &eacute;choue aussi. D'o&ugrave; une version 3, plus stable et plus \n" ;
01628     echo "compl&egrave;te pour la moyenne, avec au passage une s&eacute;paration du calcul du renvoi de la valeur calcul&eacute;e&nbsp;: \n" 
;
01629     finp
() ;
01630     
01631     pre_fichier
("moyenne3.r","cadre") ;
01632     
01633     p
("texte") ;
01634     echo "Vous aurez compris, au vu de cette progression, qu'&eacute;crire une fonction ne se fait pas forc&eacute;ment du \n" 
;
01635     echo "premier jet. Le nom et le choix de la valeur par d&eacute;faut du param&egrave;tre "
.b("oteNA")." pour supprimer \n" ;
01636     echo "les valeurs "
.b("NA")." devrait aussi &ecirc;tre d&eacute;taill&eacute;. Nous avons ici pris le parti de reproduire \n" ;
01637     echo "la valeur par d&eacute;faut de la fonction "
.hrrr("mean").", mais sans utiliser le m&ecirc;me nom de param&egrave;tre \n" ;
01638     echo "que 
$R utilise, &agrave; savoir ".b("na.omit").", ce \n" ;
01639     echo "qui est un petit peu maladroit (volontairement). \n" 
;
01640     finp
() ;
01641     
01642     h2
("$numRub.2 La fonction m&eacute;diane()") ;
01643     
01644     p
("texte") ;
01645     echo "Forts de notre exp&eacute;rience avec la fonction  "
.b("moyenne()")." pr&eacute;c&eacute;dente, nous pourrions &ecirc;tre tent&eacute;s d'&eacute;crire de \n" ;
01646     echo "suite un \"beau\" code \"stable et complet\" pour la fonction "
.b("mediane()")." comme ceci&nbsp;: \n" ;
01647     finp
() ;
01648     
01649     pre_fichier
("mediane1.r","cadre") ;
01650     
01651     p
("texte") ;
01652     echo "C'est sans doute une \"belle\" fonction, mais elle est incompl&egrave;te, \n" 
;
01653     echo "parce que la m&eacute;diane peut se calculer sur des vecteurs de caract&egrave;res \n" 
;
01654     echo "avec un nombre pair de termes. \n" 
;
01655     finp
() ;
01656     
01657     p
("texte") ;
01658     echo "On remarquera que nous avons d&eacute;sormais &eacute;crit pour le param&egrave;tre "
.b("na.rm")." au lieu de ".b("oteNA")." comme pour la fonction \n" ;
01659     echo b
("moyenne()")." pr&eacute;c&eacute;dente. C'est sans doute mieux, car cela aide &agrave; \n" ;
01660     echo "se rappeler comment on &eacute;crit cela dans les autres fonctions standards de 
$R. \n" ;
01661     finp
() ;
01662     
01663     p
("texte") ;
01664     echo "Programmer, c'est aussi &eacute;voluer, changer d'avis, &agrave; condition de le dire et de rester \n" 
;
01665     echo "coh&eacute;rent avec les autres fonctions de 
$R&nbsp;! \n" ;
01666     finp
() ;
01667     
01668     h2
("$numRub.3 La fonction decritColonne()") ;
01669     
01670     p
("texte") ;
01671     echo "
$R fournit de nombreuses fonctions pour d&eacute;crire une variable quantitative comme le poids, ou la taille. \n" ;
01672     echo "Il y a les fonctions &eacute;l&eacute;mentaires comme "
.hrrr("mean").", ".hrrr("sd","stats")." et des fonctions plus compl&egrave;tes comme \n" ;
01673     echo hrrr
("summary")."  ou ".hrrr("fivenum","stats").". \n" ;
01674     finp
() ;
01675     
01676     p
("texte") ;
01677     echo "Toutes ces fonctions ont un gros d&eacute;faut&nbsp;: elles n'indiquent pas l'unit&eacute;. \n" 
;
01678     echo "Ainsi voir une taille de 5,6 pour des adultes peut apparaitre comme une erreur pour un fran&ccedil;ais. \n" 
;
01679     echo "Avec l'indication 5,6 pieds, ce serait mieux car vu qu'un pied fait 30,47 centim&egrave;tres \n" 
;
01680     echo "la valeur 5,6 pieds correspond approximativement &agrave; 170,6 cm, ce qui montre bien qu'il ne s'agit pas d'une erreur. \n" 
;
01681     finp
() ;
01682     
01683     p
("texte") ;
01684     echo "Nous nous proposons ici d'ajouter une unit&eacute; &agrave; la \n" 
;
01685     echo "description statistique classique et de consid&eacute;rer ce param&egrave;tre comme obligatoire. \n" 
;
01686     finp
() ;
01687     
01688     p
("texte") ;
01689     echo "Nous allons nous focaliser sur les descripteurs de "
.b("tendance centrale")." que sont la moyenne et la m&eacute;diane, et sur les \n" ;
01690     echo em
("valeurs de controle")." -- il faudrait bien s&ucirc;r ajouter des indicateurs de ".em("dispersion")." absolue et relative, \n" ;
01691     echo "comme l'&eacute;cart-type, la distance interquartile, le coefficient de variation... pour &ecirc;tre plus complet -- \n" 
;
01692     echo "que sont le minimum et le maximum afin de rester dans des calculs simples et compr&eacute;hensibles. \n" 
;
01693     finp
() ;
01694     
01695     p
("texte") ;
01696     echo "Nous ne fournissons pas non plus de code pour repr&eacute;senter graphiquement les donn&eacute;es et ces indicateurs mais ce serait \n" 
;
01697     echo "indispensable s'il s'agissait d'&eacute;crire une \"vraie\" fonction statistique de description d'une variable quantitative dont \n" 
;
01698     echo "on connait l'unit&eacute;. \n" 
;
01699     finp
() ;
01700     
01701     p
("texte") ;
01702     echo "Comme programmer, c'est se rappeler des programmes d&eacute;j&agrave; &eacute;crits, nous refuserons bien &eacute;videmment d'appliquer la fonction \n" 
;
01703     echo "&agrave; des donn&eacute;es qui ne sont pas num&eacute;riques. \n" 
;
01704     finp
() ;
01705     
01706     p
("texte") ;
01707     echo "Voici un code possible pour cette \n" 
;
01708     echo "fonction&nbsp;: \n" 
;
01709     finp
() ;
01710     
01711     pre_fichier
("decrit01.r","cadre") ;
01712     
01713     p
("texte") ;
01714     echo "Le choix du nom des variables et des fonctions est important. Ici, "
.b("decritColonne()")." est sans doute maladroit \n" ;
01715     echo "et "
.b("decritQuantitative()")." aurait &eacute;t&eacute; plus appropri&eacute;. Toutefois, il est possible que l'utilisation principale \n" ;
01716     echo "de cette fonction soit d'&ecirc;tre appel&eacute;e par une fonction plus g&eacute;n&eacute;rale, nomm&eacute;e par exemple \n" 
;
01717     echo b
("decritColonnes()")." -- donc avec un ".b("s")." en plus &agrave; la fin -- et l&agrave;, le nom de la fonction se justifie \n" ;
01718     echo "tout &agrave; fait. \n" 
;
01719     finp
() ;
01720     
01721     p
("texte") ;
01722     echo "Voici un exemple d'utilisation&nbsp;: \n" 
;
01723     finp
() ;
01724     
01725     pre_fichier
("decrit01.txt","cadre") ;
01726     
01727     h2
("$numRub.4 La fonction plotCouleur()") ;
01728     
01729     p
("texte") ;
01730     echo "Il est tr&egrave;s courant d'avoir &agrave; coloriser des points dans un trac&eacute;, par exemple pour rep&eacute;rer les hommes et les femmes \n" 
;
01731     echo "dans une &eacute;tude &eacute;pid&eacute;miologique. Nous pr&eacute;sentons ici une fonction dont la syntaxe est \n" 
;
01732     echo b
("plotCouleur(x,y,facteur,couleurs)").". Ainsi, pour tracer le poids en fonction de l'age avec \n" ;
01733     echo "la couleur bleue pour les gar&ccedil;ons et rouge pour les filles, on r&eacute;aliserait l'appel \n" 
;
01734     echo b
("plotCouleur(age,poids,sexe,c(\"blue\",\"red\"))")." ou, si astucieusement on dispose d'une liste de \n" ;
01735     echo "couleurs par d&eacute;faut, l'appel peut se r&eacute;sumer &agrave; \n" 
;
01736     echo b
("plotCouleur(age,poids,sexe)").". Voici la fonction&nbsp;: \n" ;
01737     finp
() ;
01738     
01739     pre_fichier
("plotcoul01.r","cadre") ;
01740     
01741     p
("texte") ;
01742     echo "Vous aurez remarqu&eacute;, bien s&ucirc;r, que nous avons utilis&eacute; l'ellipse. \n" 
;
01743     echo "Attention toutefois&nbsp;: 
$R n'autorise pas de sp&eacute;cifier plusieurs fois le m&ecirc;me param&egrave;tre. Ainsi, puisque nous \n" ;
01744     echo "utilisons d&eacute;j&agrave; le param&egrave;tre "
.b("pch").", l'appel suivant est incorrect \n" ;
01745     echo " \n" 
;
01746     finp
() ;
01747     
01748     pre_fichier
("plotcoul01.txt","cadre") ;
01749     
01750     finblockquote
() ;
01751     
01752     #######################################################################################################################
01753     
01754     $tdmCRLM5
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Sp&eacute;cificit&eacute;s du langage $R
01755     
01756     ## -------------------------------------------------------------------------------------------
01757     
01758     blockquote
() ;
01759     
01760     p
("texte") ;
01761     echo "
$R est tr&egrave;s diff&eacute;rent des autres langages par rapport aux fonctions&nbsp;:" ;
01762     finp
() ;
01763     
01764     ul
() ;
01765     
01766     debutli
() ;
01767     p
("texte") ;
01768     echo " les fonctions sont "
.rouge("nativement vectorielles")." si les calculs utilis&eacute;s sont vectoriels, ou si on y fait appel &agrave; " ;
01769     echo " d'autres fonctions vectorielles. " 
;
01770     finp
() ;
01771     finli
() ;
01772     
01773     debutli
() ;
01774     p
("texte") ;
01775     echo " les fonctions sont "
.rouge("des objets comme les autres")." et peuvent &ecirc;tre pass&eacute;s en param&egrave;tres&nbsp;:" ;
01776     finp
() ;
01777     pre_fichier
("ifelse-fonctions.r","cadre") ;
01778     finli
() ;
01779     
01780     debutli
() ;
01781     p
("texte") ;
01782     echo rouge
(" les param&egrave;tres sont nomm&eacute;s")." et ils peuvent avoir des valeurs par d&eacute;faut, ce qui fournit une " ;
01783     echo " tr&egrave;s grande souplesse d'utilisation (et un casse-t&ecirc;te pour les m&eacute;moriser). " 
;
01784     finp
() ;
01785     finli
() ;
01786     
01787     finul
() ;
01788     
01789     p
("texte") ;
01790     echo "Par contre ce nommage n'est pas normalis&eacute; et ne peut pas l'&ecirc;tre, compte tenu des structures de donn&eacute;es de 
$R&nbsp;:" ;
01791     finp
() ;
01792     
01793     pre_fichier
("fns.r","cadre") ;
01794     
01795     finblockquote
() ;
01796     
01797     #######################################################################################################################
01798     #
01799     # progic6
01800     #
01801     #######################################################################################################################
01802     
01803     $numcours 
partie($numcours) ; pvide() ;
01804     $rubrique  
;
01805     $rubriques6 
= array() ;
01806     $rubrique
++ ; $rubriques6[$rubrique] = "Via les fonctions de base d&eacute;j&agrave; existantes" ;
01807     $rubrique
++ ; $rubriques6[$rubrique] = "Via les packages" ;
01808     $rubrique
++ ; $rubriques6[$rubrique] = "Eviter de programmer des boucles avec la famille ".rouge("*apply*") ;
01809     $rubrique
++ ; $rubriques6[$rubrique] = "Apprendre les actions courantes en $R;
01810     $rubrique
++ ; $rubriques6[$rubrique] = "Comment survivre &agrave; $R&nbsp;?" ;
01811     
01812     $tdmCRLM6 
= new tdm($rubriques6) ;
01813     $tdmCRLM6
->titre() ;
01814     $tdmCRLM6
->menu("oui","oui","nou","p$numcours") ;
01815     
01816     $numRub 
;
01817     
01818     #######################################################################################################################
01819     
01820     $tdmCRLM6
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Via les fonctions de base d&eacute;j&agrave; existantes
01821     
01822     ## -------------------------------------------------------------------------------------------
01823     
01824     blockquote
() ;
01825     
01826     p
("texte") ;
01827     echo "Lorsqu'on d&eacute;bute en programmation, il est bon d'apprendre &agrave; savoir tout faire, tout calculer. Par exemple " 
;
01828     echo " pour les statistiques usuelles, il faut savoir effectuer un calcul de moyenne, de m&eacute;diane, d'&eacute;cart-type. " 
;
01829     echo " Il faut avoir &eacute;crit au moins une fois dans sa vie la recherche du minimum, du maximum dans un vecteur, avec " 
;
01830     echo " leur nombre d'ocurrences et leurs positions pour commencer &agrave; savoir programmer. " 
;
01831     finp
() ;
01832     
01833     p
("texte") ;
01834     echo "Savoir programmer, c'est ensuite savoir utiliser les programmes des autres, donc ne pas r&eacute;inventer la roue, l'eau ti&egrave;de, etc." 
;
01835     echo 
$R dispose de nombreuses fonctions de base en standard, via les packages " ;
01836     echo hrrp
("base").", ".hrrp("stats").", ".hrrp("graphics")." et ".hrrp("utils")."&nbsp;: " ;
01837     finp
() ;
01838     
01839     blockquote
() ;
01840     $nbo 
= array() ;
01841     $nbo
["base"] = 1167 ;
01842     $nbo
["stats"] = 493 ;
01843     $nbo
["graphics"] = 87 ;
01844     $nbo
["utils"] = 198 ;
01845     table
(1,10,"collapse") ;
01846       entetesTableau
("package nbObjets liste","jaune_pastel") ;
01847       foreach (preg_split
("/\s+/","base stats graphics utils") as $nom) {
01848         tr
() ;
01849           td
()    ; echo hrrp($nom) ; fintd() ;
01850           td
("R") ; echo $nbo[$nom]."&nbsp; " fintd() ;
01851           td
()    ; echo "&nbsp; ".href("lls_".$nom.".sor") ; fintd() ;
01852         fintr
() ;
01853       } ; # fin pou chaque
01854     fintable
() ;
01855     finblockquote
() ;
01856     
01857     
01858     p
("texte") ;
01859     echo "Apprendre &agrave; programmer en 
$R consiste donc &agrave; passer beaucoup de temps, au moins au d&eacute;but," ;
01860     echo " pour savoir ce que 
$R sait d&eacute;j&agrave; faire -- et il en fait d&eacute;j&agrave; beaucoup. Car tous les traitements " ;
01861     echo " de donn&eacute;es usuels (transformations, recodages, discr&eacute;tisation, fusion...) ont d&eacute;j&agrave; &eacute;t&eacute; pass&eacute;s en revue, " 
;
01862     echo " analys&eacute;s, programm&eacute;s, parfois de fa&ccedil;on tr&egrave;s sophistiqu&eacute;e." 
;
01863     echo " On pourra consulter les fonctions " 
;
01864     echo hrrr
("transform")." et ".hrrr("stack","utils")." pour s'en rendre compte." ;
01865     finp
() ;
01866     
01867     p
("texte") ;
01868     echo "De m&ecirc;me, puisque 
$R est un logiciel pour les calculs statistiques, tous les calculs usuels et m&ecirc;me " ;
01869     echo " les calculs r&eacute;cents en statistique, bioinformatique, etc. sont d&eacute;j&agrave; impl&eacute;ment&eacute;s en 
$R. " ;
01870     echo " Une "
.b("grande conclusion")." est qu'il faut passer du temps avant de &laquo;".em("maitriser la b&ecirc;te")."&raquo;. " ;
01871     echo " L'exp&eacute;rience prouve qu'on y gagne en vitesse de d&eacute;veloppement et en compr&eacute;hension du fonctionnement du langage 
$R." ;
01872     finp
() ;
01873     
01874     p
("texte") ;
01875     echo "Soyons clairs&nbsp;: sauf si vous inventez une nouvelle m&eacute;thode de calcul en statistiques, " 
;
01876     echo b
("vous n'avez pas &agrave; programmer le moindre calcul statistique en $R").". " ;
01877     echo " Vous avez &agrave; lire les donn&eacute;es, appeler les fonctions de 
$R qui calculent, vous avez &agrave; mettre en forme les r&eacute;sultats, mais " ;
01878     echo " vous n'avez pas &agrave; programmer le moindre calcul statistique en 
$R (redite volontaire). " ;
01879     finp
() ;
01880     
01881     finblockquote
() ;
01882     
01883     #######################################################################################################################
01884     
01885     $tdmCRLM6
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; #  Via les packages
01886     
01887     ## -------------------------------------------------------------------------------------------
01888     
01889     blockquote
() ;
01890     
01891     p
("texte") ;
01892     echo "Plus encore que les deux mille et quelques fonctions des quatre packages de la section pr&eacute;c&eacute;dente, c'est "
;
01893     echo " la "
.em("foultitude")." des packages sp&eacute;cialis&eacute;s qui fait la richesse de $R  et qui le rend incomparable pour les " ;
01894     echo " calculs et les graphiques statistiques. " 
;
01895     finp
() ;
01896     
01897     p
("texte") ;
01898     echo "M&ecirc;me si d'autres langages peuvent &ecirc;tre consid&eacute;r&eacute;s comme \"plus beaux\", \"plus propres\", \"plus efficaces\", disons comme " 
;
01899     echo href
("../../../tuteurs/tutruby.php","Ruby").", " ;
01900     echo href
("../../../tuteurs/tutpython.php","Python").", " ;
01901     echo href
("http://fr.wikipedia.org/wiki/Java_%28langage%29","Java").",  " ;
01902     echo href
("http://fr.wikipedia.org/wiki/C_%28langage%29","C")."..., " ;
01903     echo " aucun autre langage de programmation n'est aussi complet d&egrave;s qu'il s'agit de graphiques et de calculs statistiques. La preuve&nbsp;:" 
;
01904     echo " ces langages ont pr&eacute;f&eacute;r&eacute; d&eacute;velopper des interfaces de dialogue avec 
$R plut&ocirc;t que de r&eacute;impl&eacute;menter les m&ecirc;mes calculs ";
01905     echo " et graphiques. C'est ainsi qu'on trouve " 
;
01906     echo href
("http://rpy.sourceforge.net/","rpy").", " ;
01907     echo href
("https://sites.google.com/a/ddahl.org/rinruby-users/Home","rinruby").", " ;
01908     echo href
("http://cran.r-project.org/web/packages/rJava/index.html","rJava").", " ;
01909     echo href
("http://cran.r-project.org/web/packages/Rcpp/index.html","Rcpp")."..." ;
01910     finp
() ;
01911     
01912     p
("texte") ;
01913     echo "Il suffit de consulter chaque jour la " 
;
01914     echo href
("http://cran.r-project.org/","liste des packages ajout&eacute;s quotidiennement")." pour constater que le nombre de packages grandit vraiment ";
01915     echo " tr&egrave;s vite et qu'aucun autre langage ne croit aussi vite...  " 
;
01916     finp
() ;
01917     
01918     p
("texte") ;
01919     echo "M&ecirc;me dans certains domaines o&ugrave; on pourrait ne pas l'y attendre, 
$R se r&eacute;v&eacute;le performant gr&acirc;ce &agrave; son aspect " ;
01920     echo rouge
("vectoriel").". Le package ".hrrp("XML")." et le livre associ&eacute; en sont un tr&egrave;s bon exemple." ;
01921     finp
() ;
01922     
01923     p
() ;
01924     nbsp
(10) ;
01925     $img 
"Rxml.jpg" ;
01926     echo href
("http://www.springer.com/gp/book/9781461478997",img($img,"",150)) ;
01927     finp
() ;
01928     
01929     p
("texte") ;
01930     echo "Au passage, l'un des points forts de 
$R est la mise en forme ou la restructuration des donn&eacute;es. " ;
01931     echo " On pourra consulter les packages " 
;
01932     echo hrrp
("plyr")." et ".hrrp("reshape2")." pour s'en rendre compte" ;
01933     finp
() ;
01934     
01935     finblockquote
() ;
01936     
01937     #######################################################################################################################
01938     
01939     $tdmCRLM6
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Eviter de programmer des boucles avec la famille *apply*
01940     
01941     ## -------------------------------------------------------------------------------------------
01942     
01943     blockquote
() ;
01944     
01945     p
("texte") ;
01946     echo "Programmer des calculs, des affichages revient souvent &agrave; "
.b("appliquer")." un m&ecirc;me traitement " ;
01947     echo " &agrave; de nombreux \"objets\". Dans la mesure o&ugrave; 
$R distingue les vecteurs, les matrices et les listes " ;
01948     echo " (dont les data frames), il n'est pas &eacute;tonnant que ce mot "
.b("appliquer")." se d&eacute;cline en plusieurs versions " ;
01949     echo " suivant les structures de donn&eacute;es&nbsp;:" 
;
01950     finp
() ;
01951     
01952     pre_fichier
("apply.txt","cadre") ;
01953     
01954     p
("texte") ;
01955     echo "La fonction " 
;
01956     echo hrrr
("apply")." utilise des objets \"matrice\". Sa syntaxe de base utilise les param&egrave;tres " ;
01957     echo b
("X")." qui est la matrice  ou un objet assimilable &agrave; une matrice, " ;
01958     echo b
("FUN")." la fonction &agrave; appliquer, qu'elle soit nomm&eacute;e ou anonyme et " ;
01959     echo b
("MARGIN")." pour pr&eacute;ciser si on applique la fonction dans le sens des lignes (MARGIN=1) ou des " ;
01960     echo " colonnes (MARGIN=2)." 
;
01961     finp
() ;
01962     
01963     p
("texte") ;
01964     echo "La fonction " 
;
01965     echo hrrr
("lapply")." utilise une liste nomm&eacute;e " ;
01966     echo b
("X")." et lui applique la fonction " ;
01967     echo b
("FUN")." &eacute;l&eacute;ment par &eacute;l&eacute;ment." ;
01968     echo " L'objet renvoy&eacute; est une liste. " 
;
01969     finp
() ;
01970     
01971     p
("texte") ;
01972     echo "La fonction " 
;
01973     echo hrrr
("lapply","","sapply()")." ex&eacute;cute ".b("lapply()")." et en simplifie la sortie ";
01974     echo " pour renvoyer un vecteur ou une matrice. "
.b("sapply")." utilise donc les m&ecirc;mes param&egrave;tres que ".b("lapply").". " ;
01975     finp
() ;
01976     
01977     p
("texte") ;
01978     echo "La fonction " 
;
01979     echo hrrr
("rapply")." ex&eacute;cute r&eacute;cursivement son param&egrave;tre ".b("f")." sur son autre param&egrave;tre ".b("object").", " ;
01980     echo " ce que ne savent pas faire les fonctions pr&eacute;c&eacute;dentes." 
;
01981     finp
() ;
01982     
01983     p
("texte") ;
01984     echo "La fonction " 
;
01985     echo hrrr
("tapply")." permet de d&eacute;couper le param&egrave;tre ".b("X")." selon le param&egrave;tre ".b("INDEX")." avant d'appliquer " ;
01986     echo " son param&egrave;tre "
.b("FUN")." &agrave; chaque d&eacute;coupage obtenu. C'est donc en quelque sorte l'enchainement de " ;
01987     echo hrrr
("split")." et " ;
01988     echo hrrr
("lapply").". "  ;
01989     finp
() ;
01990     
01991     p
("texte") ;
01992     echo "La fonction " 
;
01993     echo hrrr
("lapply","","vapply")." permet de pr&eacute;ciser &agrave; ".b("sapply")." quel type de donn&eacute;es on obtiendra en sortie." ;
01994     finp
() ;
01995     
01996     
01997     p
("texte") ;
01998     echo "La fonction " 
;
01999     echo hrrr
("mapply")." travaille en \"multivari&eacute;\"." ;
02000     finp
() ;
02001     
02002     
02003     p
("texte") ;
02004     echo "Notre " 
;
02005     echo href
("../Programmation_avancee/progr.php?n=1&amp;m=e","cours 1") ;
02006     echo " de " 
;
02007     echo href
("../Programmation_avancee/progr.php","programmation $R avanc&eacute;e").", " ;
02008     echo " exercice 5 et " 
;
02009     echo href
("../Programmation_avancee/progr.php?n=1&amp;m=e","sa solution") ;
02010     echo" montre par l'exemple comment utiliser ces fonctions." 
;
02011     finp
() ;
02012     
02013     finblockquote
() ;
02014     
02015     #######################################################################################################################
02016     
02017     $tdmCRLM6
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Apprendre les actions courantes en R
02018     
02019     ## -------------------------------------------------------------------------------------------
02020     
02021     blockquote
() ;
02022     
02023     p
("texte") ;
02024     echo "S'il n'est pas possible de tout apprendre en 
$R, il est facile de pr&eacute;voir un planning et un ordre " ;
02025     echo " pour apprendre les actions courantes en 
$R&nbsp;:" ;
02026     finp
() ;
02027     
02028     ol
() ;
02029     
02030       debutli
() ; p("texte") ;
02031       echo "On commence presque toujours par lire des donn&eacute;es. Donc tout ce qui se nomme " 
;
02032       echo vert
("read.").rouge("*")." est bon &agrave; prendre et &agrave; apprendre, dont la lecture des fichiers Excel, des fichiers PDF " ;
02033       echo " ou autres fichiers XML ou Fasta..." 
;
02034       echo "Si on ne lit pas des fichiers, c'est qu'on lit des bases de donn&eacute;es ou qu'on simule des donn&eacute;es. L&agrave; encore les " 
;
02035       echo "packages de 
$R sont faciles &agrave; trouver qui remplissent ces t&acirc;ches, " ;
02036       echo " par exemple avec "
.href("http://finzi.psych.upenn.edu/nmz.html","R Site Search")."..." ;
02037       finp
()  ;
02038     
02039       pre_fichier
("read.txt","cadre") ;
02040     
02041       finli
() ;
02042     
02043       debutli
() ; p("texte") ;
02044       echo "Avec des donn&eacute;es, on effectue des calculs, on produit des graphiques. Les " 
;
02045       echo href
("http://cran.r-project.org/web/views/",em("task views")) ;
02046       echo " du "
.href("http://cran.r-project.org/","CRAN") ;
02047       echo " permettent de s'y retrouver. " 
;
02048       echo " Pour celles et ceux qui travaillent dans le domaine de la bioinformatique, on rajoutera les pages "
;
02049       echo href
("http://www.bioconductor.org/packages/release/BiocViews.html#___Software","Explore packages") ;
02050       echo " et " 
;
02051       echo href
("http://www.bioconductor.org/help/","help") ;
02052       echo " de " 
;
02053       echo href
("http://www.bioconductor.org/","bioconductor") ;
02054       echo "." 
;
02055       finp
() ;
02056     
02057       p
("texte") ;
02058       echo "Une fois maitris&eacute;s les calculs &eacute;l&eacute;mentaires, vous pouvez aborder les mod&eacute;lisations classiques qui reposent sur le mod&egrave;le lin&eacute;aire (soit  " 
;
02059       echo " la fonction "
.hrrr("lm","stats").") et " ;
02060       echo " sa g&eacute;n&eacute;ralisation (soit la fonction "
.hrrr("glm","stats").") soit basculer vers le non lin&eacute;aire, par exemple avec " ;
02061       echo lafonction
("nlm","stats")." ou des fonctions comme " ;
02062       echo hrrr
("loess","stats")." ou " ;
02063       echo hrrr
("lowess","stats").". " ;
02064       finp
()  ;
02065     
02066       pre_fichier
("lm.txt","cadre") ;
02067     
02068       p
("texte") ;
02069       echo "Pour les tests, 
$R impl&eacute;mente \"tout ce qui bouge\" et ".em("plus si affinit&eacute;s,") ;
02070       echo " ce qui se nomme plus ou moins "
.b("*.test()")." ou ".hrrr("anova","stats")."&nbsp;:" ;
02071       finp
() ;
02072     
02073       pre_fichier
("test.txt","cadre") ;
02074     
02075       finli
() ;
02076     
02077       debutli
() ; p("texte") ;
02078       echo "Il faut ensuite mettre en forme les calculs, produire des rapports, int&eacute;grer les graphiques, exporter vers " 
;
02079       echo " des formats classiques comme les pr&eacute;c&eacute;dents (Excel, PDF, base de donn&eacute;es, XML...). Donc il faut approfondir "
;
02080       echo " tout ce qui se nomme "
.vert("write.").rouge("*")." et tout ce qui se trouve dans le package ".hrrp("gdata").". " ;
02081       finp
() ;
02082     
02083       pre_fichier
("write.txt","cadre") ;
02084     
02085       finli
() ;
02086     
02087     finol
() ;
02088     
02089     finblockquote
() ;
02090     
02091     #######################################################################################################################
02092     
02093     $tdmCRLM6
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Comment survivre &agrave; R
02094     
02095     ## -------------------------------------------------------------------------------------------
02096     
02097     blockquote
() ;
02098     
02099     p
("texte") ;
02100     echo "Malheureusement, la richesse de 
$R en fait aussi son plus gros d&eacute;faut. " ;
02101     echo " Il faut apprendre une grosse centaine de fonctions (et leurs param&egrave;tres) " 
;
02102     echo " avant de commencer &agrave; &eacute;crire des programmes concis, "
.b("il faut d&eacute;sapprendre les boucles ") ;
02103     echo " dans un certain nombre de cas avant de bien profiter des aspects "
.rouge("vectoriels")." de $R, " ;
02104     echo " il faut &ecirc;tre &agrave; l'aise avec les m&eacute;thodes statistiques pour s'y retrouver facilement dans les " 
;
02105     echo " packages et les options impl&eacute;ment&eacute;es, bref ce n'est pas une mince affaire que de bien programmer en 
$R." ;
02106     finp
() ;
02107     
02108     p
("texte") ;
02109     echo "Heureusement, avec &laquo;du coeur &agrave; l'ouvrage&raquo; et de nombreuses heures d'entrainement, on y arrive "
;
02110     echo "toujours&nbsp;!" 
;
02111     finp
() ;
02112     
02113     finblockquote
() ;
02114     
02115     #######################################################################################################################
02116     #
02117     # progic7
02118     #
02119     #######################################################################################################################
02120     
02121     $numcours 
partie($numcours) ; pvide() ;
02122     $rubrique  
;
02123     $rubriques7 
= array() ;
02124     $rubrique
++ ; $rubriques7[$rubrique] = "Structure de donn&eacute;es classiques des autres langages" ;
02125     $rubrique
++ ; $rubriques7[$rubrique] = "Probl&egrave;mes demandant des comp&eacute;tences techniques en algorithmique" ;
02126     $rubrique
++ ; $rubriques7[$rubrique] = "Probl&egrave;mes de grande taille (big data)" ;
02127     $rubrique
++ ; $rubriques7[$rubrique] = "Probl&egrave;mes de grande ampleur (big computing)" ;
02128     $rubrique
++ ; $rubriques7[$rubrique] = "La r&eacute;cursivit&eacute;" ;
02129     
02130     $tdmCRLM7 
= new tdm($rubriques7) ;
02131     $tdmCRLM7
->titre() ;
02132     $tdmCRLM7
->menu("oui","oui","nou","p$numcours") ;
02133     
02134     $numRub 
;
02135     
02136     #######################################################################################################################
02137     
02138     $tdmCRLM7
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Structure de donn&eacute;es classiques des autres langages
02139     
02140     ## -------------------------------------------------------------------------------------------
02141     
02142     blockquote
() ;
02143     
02144     
02145     p
("texte") ;
02146     echo "Lorsqu'on suit des cours de programmation, on apprend des techniques classiques et des mod&egrave;les de " 
;
02147     echo " r&eacute;solution de probl&egrave;mes, nomm&eacute;s en anglais " 
;
02148     echo href
("http://fr.wikipedia.org/wiki/Patron_de_conception","Design Patterns").". ";
02149     echo " On apprend aussi &agrave; utiliser des " 
;
02150     echo href
("http://fr.wikipedia.org/wiki/Structure_de_donn%C3%A9es","structures de donn&eacute;es adapt&eacute;es").", " ;
02151     echo " comme les piles, les queues, les files, les graphes (dont les arbres), les listes chain&eacute;es, les tableaux associatifs..." 
;
02152     echo " Il faut donc de nombreuses heures de cours et de pratique avant de maitriser la programmation. Les cours pr&eacute;sent&eacute;s " 
;
02153     echo " ici ne peuvent pr&eacute;tendre se substituer &agrave; ces enseignements traditionnels, tout au plus sensibiliser &agrave; l'importance de " 
;
02154     echo " ces concepts via quelques exemples choisis." 
;
02155     finp
() ;
02156     
02157     p
("texte") ;
02158     echo "On trouvera donc dans les exercices de ce cours des graphes, des arbres et des tableaux associatifs &agrave; titre " 
;
02159     echo " d'illustration." 
;
02160     finp
() ;
02161     
02162     p
("texte") ;
02163     echo "Il faut noter aussi que l'utilisation de 
$R est souvent li&eacute;e &agrave; des calculs statistiques, discipline qui a ses propres " ;
02164     echo " structures comme les s&eacute;ries chronologiques, les variables ordinales, les matrices de distances, les arbres de classification hi&eacute;rarchique... " 
;
02165     echo " et ses propres m&eacute;thodes comme le mod&egrave;le lin&eacute;aire, " 
;
02166     echo " les intervalles de confiance... " 
;
02167     finp
() ;
02168     
02169     finblockquote
() ;
02170     
02171     #######################################################################################################################
02172     
02173     $tdmCRLM7
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Probl&egrave;mes demandant des comp&eacute;tences techniques en algorithmique
02174     
02175     ## -------------------------------------------------------------------------------------------
02176     
02177     blockquote
() ;
02178     
02179     # plus grande sous-chaine r&eacute;p&eacute;t&eacute;e via un tableau des suffixes
02180     
02181     p
("texte") ;
02182     echo "Voici un probl&egrave;me qui a l'air presque anodin&nbsp;: quelle est la plus grande sous-chaine de caract&egrave;res r&eacute;p&eacute;t&eacute;e dans une chaine de caract&egrave;res&nbsp;?" 
;
02183     echo " Attention&nbsp;: il ne s'agit pas de trouver la lettre la plus souvent utilis&eacute;e, mais une sous-chaine. Pour un texte \"litt&eacute;raire\", avec des " 
;
02184     echo " avec des \"vrais\" mots, c'est facile &agrave; faire et rapide. Voir par exemple le site " 
;
02185     echo href
("http://forge.info.univ-angers.fr/~gh/Wanalexies/f_dicos.php","analexies").". ";
02186     $adn 
"../../../Abdc/Data/putida_gb_1.fasta.zip" ;
02187     echo "Mais pour une s&eacute;quence d'ADN comme "
.href($adn,"celle de Pseudomonas putida GB-1")." (soit un peu plus de 6 millions de lettres), " ;
02188     echo " comment faire&nbsp;?"
;
02189     # plus grande sous-chaine r&eacute;p&eacute;t&eacute;e via un tableau des suffixes
02190     echo 
"" ;
02191     finp
() ;
02192     
02193     p
("texte") ;
02194     echo "C'est gr&acirc;ce &agrave; l'&eacute;tude de structures de donn&eacute;es adapt&eacute;es comme celle de " 
;
02195     $tds 
"http://en.wikipedia.org/wiki/Suffix_array" ;
02196     echo href
($tds,"tableau des suffixes")." que le probl&egrave;me se r&eacute;soud de fa&ccedil;on &laquo;&nbsp;assez rapide&nbsp;&raquo; (quelques dizaines de secondes " ;
02197     echo " sur un ordinateur r&eacute;cent un peu puissant, pour "
.b("Pseudomonas putida GB-1")."). " ;
02198     echo " Il est clair qu'une structure comme celle-l&agrave; ne s'invente pas en pensant dix minutes au probl&egrave;me. " 
;
02199     echo " C'est pourquoi il y a un moment o&ugrave; savoir programmer dans un langage ne suffit plus&nbsp;: il faut aussi savoir " 
;
02200     echo " inventer des algorithmes, connaitre les algorithmes classiques et les structures de donn&eacute;es associ&eacute;es. " 
;
02201     echo " Voici deux r&eacute;f&eacute;rences pour progresser dans ce domaine&nbsp;:" 
;
02202     finp
() ;
02203     
02204     $r1 
"http://pauillac.inria.fr/~maranget/X/421/poly/poly.pdf" ;
02205     $r2 
"http://algs4.cs.princeton.edu/home/" ;
02206     $r3 
"poly_technique.pdf" ;
02207     
02208     ul
() ;
02209     
02210     debutli
() ;
02211     p
() ;
02212     echo href
($r1,"Algorithmique et Programmation JAVA")."&nbsp;: un polycopi&eacute; en fran&ccedil;ais de polytechnique " ;
02213     echo "("
.href($r3,"version locale").")" ;
02214     echo "&nbsp;;" 
;
02215     finp
() ;
02216     finli
() ;
02217     
02218     debutli
() ;
02219     p
() ;
02220     echo href
($r2,"Algorithms")."&nbsp;: une grande r&eacute;f&eacute;rence anglaise sur les algorithmes." ;
02221     finp
() ;
02222     finli
() ;
02223     
02224     finul
() ;
02225     
02226     finblockquote
() ;
02227     
02228     #######################################################################################################################
02229     
02230     $tdmCRLM7
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Probl&egrave;mes de grande taille
02231     
02232     ## -------------------------------------------------------------------------------------------
02233     
02234     blockquote
() ;
02235     
02236     p
("texte") ;
02237     echo "Lorsque les donn&eacute;es sont tr&egrave;s importantes (disons quelques dizaines de giga octets ou tera octets), " 
;
02238     echo " ce qui est souvent le cas en bioinformatique, en [m&eacute;ta]g&eacute;nomique, de nouvelles difficult&eacute;s surgissent&nbsp;:" 
;
02239     echo " il n'est plus possible de charger les donn&eacute;es en m&eacute;moire, ou seulement partiellement, les calculs ne peuvent plus " 
;
02240     echo " s'ex&eacute;cuter sur un seul ordinateur et il faut recourir &agrave; un "
.b("cluster")." ou &agrave; une ".b("grid")." de calculateurs..." ;
02241     finp
() ;
02242     
02243     p
("texte") ;
02244     echo "La programmation en \"grande dimension\" (autre nom du "
.b("big data").") n&eacute;cessite des approches algorithmiques diff&eacute;rentes de " ;
02245     echo " la programmation classique. Ce sujet est beaucoup trop technique pour pouvoir &ecirc;tre abord&eacute; dans un cours comme celui-ci" 
;
02246     echo " qui est une "
.em("petite")." introduction &agrave; la programmation classique, mais il est bon de savoir qu'il existe des solutions, " ;
02247     echo " par exemple "
.href("http://revolutionanalytics.com/","Revolution R").", qu'on y parle " ;
02248     echo href
("https://fr.wikipedia.org/wiki/Hadoop","Hadoop") ;
02249     echo " et autres " 
;
02250     echo href
("https://fr.wikipedia.org/wiki/MapReduce","map/reduce") ;
02251     echo" ou " 
;
02252     echo href
("http://cryto.net/~joepie91/blog/2015/05/04/functional-programming-in-javascript-map-filter-reduce/","map/filter/reduce") ;
02253     echo ", de la "
.href("https://fr.wikipedia.org/wiki/Programmation_fonctionnelle","programmation fonctionnelle")."." ;
02254     finp
() ;
02255     
02256     finblockquote
() ;
02257     
02258     #######################################################################################################################
02259     
02260     $tdmCRLM7
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Probl&egrave;mes de grande ampleur
02261     
02262     ## -------------------------------------------------------------------------------------------
02263     
02264     blockquote
() ;
02265     
02266     p
("texte") ;
02267     echo "Contrairement &agrave; un probl&egrave;me de grande taille, un probl&egrave;me de grande ampleur peut avoir des donn&eacute;es de taille " 
;
02268     echo "&laquo;raisonnable&raquo; mais leur traitement n&eacute;cessite des capacit&eacute;s gigantesques. Un exemple classique est la " 
;
02269     echo " d&eacute;termination (calcul&nbsp;?) de "
.b("sous-").rouge("s&eacute;quences").b(" r&eacute;p&eacute;t&eacute;es")." &agrave; ne pas confondre avec le " ;
02270     echo " calcul de "
.b("sous-").vert("chaines").b(" r&eacute;p&eacute;t&eacute;es")." (qui, lui, se traite &laquo;assez facilement&raquo;). " ;
02271     echo " Dans les phrases "
.b("un bateau qui va sur l'eau")." et " ;
02272     echo b
(" mon ami est en bateau").", la chaine ".vert("eau")." est une sous-chaine r&eacute;p&eacute;t&eacute;e. " ;
02273     echo " Dans les phrases " 
;
02274     echo b
("mon papa est dans un bateau") ;
02275     echo " et " 
;
02276     echo b
("pour mon tonton, il y a un souci").", " ;
02277     echo " la sous-s&eacute;quence not&eacute;e " 
;
02278     echo rouge
("mon") ;
02279     echo "*" 
;
02280     echo rouge
("un") ;
02281     echo ", qui signifie le mot "
rouge("mon")." suivi quelque part du mot "rouge("un") ;
02282     echo ", est une sous-s&eacute;quence r&eacute;p&eacute;t&eacute;e." 
;
02283     echo " Ce genre de probl&egrave;me est classique lorsqu'on s'int&eacute;resse aux s&eacute;quences d'ADN ou d'acides amin&eacute;s." 
;
02284     finp
() ;
02285     
02286     p
("texte") ;
02287     echo "L&agrave; encore, la programmation en \"grande complexit&eacute;\" (autre nom pour dire "
.b("grande ampleur").") n&eacute;cessite des approches algorithmiques diff&eacute;rentes de " ;
02288     echo " la programmation classique. Ce sujet est beaucoup trop technique pour pouvoir &ecirc;tre abord&eacute; dans un cours comme celui-ci" 
;
02289     echo " qui est une "
.em("petite")." introduction &agrave; la programmation classique, mais il est bon de savoir qu'il n'existe pas toujours des solutions " ;
02290     echo b
("exactes")."  et qu'on doit alors se contenter de ".b("r&eacute;sultats approch&eacute;s").", d'".b("approximations")." souvent issues " ;
02291     echo " d'"
.href("https://fr.wikipedia.org/wiki/Heuristique_%28math%C3%A9matiques%29","heuristiques")." voire de " ;
02292     echo href
("https://fr.wikipedia.org/wiki/M%C3%A9taheuristique","m&eacute;taheuristiques")."..." ;
02293     finp
() ;
02294     
02295     finblockquote
() ;
02296     
02297     #######################################################################################################################
02298     
02299     $tdmCRLM7
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # La r&eacute;cursivit&eacute;
02300     
02301     ## -------------------------------------------------------------------------------------------
02302     
02303     blockquote
() ;
02304     
02305     p
("texte") ;
02306     echo "Programmer, c'est &eacute;crire des programmes. De nombreux programmes utilisent des fonctions. " 
;
02307     echo " Il y a parfois des fa&ccedil;ons \"naturelles\" ou \"&eacute;l&eacute;gantes\" de traiter un probl&egrave;me. Par exemple, voici une " 
;
02308     echo " m&eacute;thode de tri&nbsp;:" 
;
02309     finp
() ;
02310     
02311     div
("cadre") ;
02312     blockquote
() ;
02313     p
("aligne") ;
02314     echo em
("Pour ".b("trier")." une liste de valeurs par ordre d&eacute;croissant, il suffit de trouver le plus grand &eacute;l&eacute;ment de la liste, ") ;
02315     echo em
(" de l'afficher, puis de l'enlever de la liste et de ".b("trier")." la liste restante par ordre d&eacute;croissant, jusqu'&agrave; ce qu'il ") ;
02316     echo em
("n'y ait plus de valeurs &agrave; trier. ") ;
02317     finp
() ;
02318     finblockquote
() ;
02319     findiv
() ;
02320     
02321     p
("texte") ;
02322     echo "Cette d&eacute;finition du tri qui fait r&eacute;f&eacute;rence &agrave; son propre tri se nomme un appel "
.b("r&eacute;cursif").". Ecrire des fonctions " ;
02323     echo " r&eacute;cursives, savoir quand les utiliser et comment s'en passer ou comment les convertir en fonctions " 
;
02324     echo " non r&eacute;cursives (lorsque c'est concr&egrave;tement faisable) est une partie non n&eacute;gligeable de l'algorithmique traditionnelle. " 
;
02325     echo " Pour aller plus loin dans ce sujet, on pourra consulter "
;
02326     $l1 
"coursVivien.pdf" ;
02327     $a1 
"http://perso.ens-lyon.fr/frederic.vivien/Enseignement/Algo-2001-2002/Cours.pdf" ;
02328     $a2 
"http://fr.wikipedia.org/wiki/Fonction_d%27Ackermann" ;
02329     echo href
($a1,"le cours d'algorithmique de F. Vivien").", chapitre 3 " ;
02330     echo "("
.href($l1,"version locale").")" ;
02331     echo " et la d&eacute;finition de "
.href("http://fr.wikipedia.org/wiki/Fonction_d%27Ackermann","la fonction d'Ackermann")." qui est, " ;
02332     echo " en principe, d&eacute;r&eacute;cursivable... " 
;
02333     
02334     finp
() ;
02335     
02336     finblockquote
() ;
02337     
02338     #######################################################################################################################
02339     #
02340     # progic8
02341     #
02342     #######################################################################################################################
02343     
02344     $numcours 
partie($numcours) ; pvide() ;
02345     $rubrique  
;
02346     $rubriques8 
= array() ;
02347     $rubrique
++ ; $rubriques8[$rubrique] = "But de cette section" ;
02348     $rubrique
++ ; $rubriques8[$rubrique] = "Un comportement bizarre de R";
02349     $rubrique
++ ; $rubriques8[$rubrique] = "D&eacute;boggage" ;
02350     $rubrique
++ ; $rubriques8[$rubrique] = "Ecrire &lt;&lt;- n'est pas une faute de frappe" ;
02351     $rubrique
++ ; $rubriques8[$rubrique] = "Profilage" ;
02352     $rubrique
++ ; $rubriques8[$rubrique] = "Optimisation" ;
02353     
02354     $tdmCRLM8 
= new tdm($rubriques8) ;
02355     $tdmCRLM8
->titre() ;
02356     $tdmCRLM8
->menu("oui","oui","nou","p$numcours") ;
02357     
02358     $numRub 
;
02359     
02360     #######################################################################################################################
02361     
02362     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # But de cette section
02363     
02364     ## -------------------------------------------------------------------------------------------
02365     
02366     blockquote
() ;
02367     
02368     p
() ;
02369     echo "Nous allons dans cette page essayer de r&eacute;pondre &agrave; trois questions&nbsp;:"
;
02370     finp
() ;
02371     
02372     ol
() ;
02373     
02374     debutli
() ; p("texte") ;
02375     echo "Mon programme ne fonctionne pas comme je le voudrais." 
;
02376     echo " O&ugrave; est l'erreur&nbsp;?" 
;
02377     finp
() ; finli() ;
02378     
02379     debutli
() ; p("texte") ;
02380     echo " Mon programme est lent. " 
;
02381     echo " Quelle partie du code est la plus lente&nbsp;?" 
;
02382     finp
() ; finli() ;
02383     
02384     debutli
() ; p("texte") ;
02385     echo "Comment acc&eacute;l&eacute;rer le code qui est lent&nbsp;?" 
;
02386     finp
() ; finli() ;
02387     
02388     finol
() ;
02389     
02390     p
("texte") ;
02391     echo "
$R fournit des outils qui permettent de r&eacute;pondre aux deux premi&egrave;res questions " ;
02392     echo " car apr&egrave;s tout, il ne s'agit que d'analyser le code du programme ou son ex&eacute;cution. Par contre, " 
;
02393     echo " c'est &agrave; vous de modifier le code pour le rendre plus rapide sachant que de par " 
;
02394     echo " sa conception, 
$R  est \"lent\". " ;
02395     finp
() ;
02396     
02397     p
("texte") ;
02398     echo "Il est aussi possible que votre probl&egrave;me &agrave; traiter \n" 
;
02399     echo "soit un probl&egrave;me \"difficile\", NP-complet ou qu'il \"explose combinatoirement\", ce qui signifie \n" 
;
02400     echo "que de toutes fa&ccedil;ons il sera tr&egrave;s tr&egrave;s long &agrave; ex&eacute;cuter (si vous avez le choix, n'h&eacute;sitez pas \n" 
;
02401     echo "&agrave; essayer de programmer ce genre de probl&egrave;mes&nbsp;: comme c'est long, on peut passer beaucoup de \n" 
;
02402     echo "temps &agrave; la machine &agrave; caf&eacute; sans culpabiliser de peur de rater la fin de l'ex&eacute;cution \n" 
;
02403     echo "du programme&nbsp;!). \n" 
;
02404     finp
() ;
02405     
02406     p
("texte") ;
02407     echo "Nous essaierons de fournir pour cette derni&egrave;re partie quelques pistes \n" 
;
02408     echo " de solutions, lorsqu'il doit &ecirc;tre possible d'acc&eacute;l&eacute;rer l'ex&eacute;cution, ce qui n'est  \n" 
;
02409     echo "pas toujours le cas... \n" 
;
02410     finp
() ;
02411     
02412     p
("texte") ;
02413     echo "Mais commen&ccedil;ons par un programme qui semble &agrave; la fois fonctionner et ne pas fonctionner, \n" 
;
02414     echo "et qui, en tous cas, ne s'arr&ecirc;te pas d&egrave;s le d&eacute;but de l'ex&eacute;cution. Il ne s'agit donc pas \n" 
;
02415     echo "d'un probl&egrave;me simple &agrave; r&eacute;soudre ou d'une erreur na&iuml;ve de programmation. \n" 
;
02416     finp
() ;
02417     
02418     finblockquote
() ;
02419     
02420     #######################################################################################################################
02421     
02422     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Un comportement bizarre de R
02423     
02424     ## -------------------------------------------------------------------------------------------
02425     
02426     blockquote
() ;
02427     
02428     p
("texte") ;
02429     echo "Il est rare qu'un programme \"marche\" du premier coup. Parfois, m&ecirc;me si \n" 
;
02430     echo "on est convaincu que 
$R  va faire ce qu'on lui demande et qu'&agrave; la main \n" ;
02431     echo "on pense avoir r&eacute;solu le probl&egrave;me, 
$R  semble se comporter bizarrement. \n" ;
02432     finp
() ;
02433     
02434     p
("texte") ;
02435     echo "Voici un exemple de programme un peu \"surprenant\". On demande &agrave; 
$R \n" ;
02436     echo "de cr&eacute;er une matrice avec deux lignes et deux colonnes. L'utilisateur peut \n" 
;
02437     echo "alors supprimer la ligne ou la colonne de son choix et voir ce qu'il reste \n" 
;
02438     echo "de la matrice. Mais bizarrement, 
$R  a l'air de \"perdre\" la matrice \n" ;
02439     echo "avant la fin... \n" 
;
02440     finp
() ;
02441     
02442     p
("texte") ;
02443     echo "Le code 
$R  associ&eacute;, fourni ci-dessous, est court, simple &agrave; lire et &agrave; comprendre. \n" ;
02444     finp
() ;
02445     
02446     pre_fichier
("bizar01.r","cadre") ;
02447     
02448     p
("texte") ;
02449     echo "Mais l'ex&eacute;cution de ce code est un peu \"myst&eacute;rieuse\"&nbsp;: \n" 
;
02450     finp
() ;
02451     
02452     pre_fichier
("bizar02.txt","cadre") ;
02453     
02454     p
("texte") ;
02455     echo "Il semblerait que 
$R  n'arrive plus &agrave; trouver le nombre de lignes et de colonnes \n" ;
02456     echo "de la matrice car au niveau de la derni&egrave;re suppression, juste avant l'erreur, \n" 
;
02457     echo "il y a affich&eacute; "
.noir("\"avec lignes\"")." mais aucun nombre de lignes n'est affich&eacute;. \n" ;
02458     finp
() ;
02459     
02460     p
("texte") ;
02461     echo "Pour un(e) professionnel(le) de 
$R , ce comportement est normal car \n" ;
02462     echo "il est d&eacute;crit dans \n" 
;
02463     echo "l'aide (longue, tr&egrave;s longue) de la fonction "
.hrrr("Extract","","[()")." et dans l'aide de la fonction ".hrrr("drop")."\n" ;
02464     echo "obtenues par "
.noir("help(\"[\")")." et ".noir("help(drop)").". \n" ;
02465     finp
() ;
02466     
02467     p
("texte") ;
02468     echo "Sauf que les explications -- en anglais -- ne sont pas tr&egrave;s explicites : \n" 
;
02469     finp
() ;
02470     
02471     pre_fichier
("bizar04.txt","cadre") ;
02472     
02473     p
("texte") ;
02474     echo "Pour essayer de comprendre ce qui se passe, on peut tenter d'aller \n" 
;
02475     echo " &agrave; la p&ecirc;che (sous-entendu \"aux informations\") " 
;
02476     echo " &agrave; l'aide de la fonction "
.hrrr("print")." via ".noir("print(mat)")." \n" ;
02477     echo "ou de "
.noir("print(nrow(mat))").". \n" ;
02478     echo "Cela se r&eacute;v&egrave;lera sans doute difficile et peu productif parce que si "
.noir("x")." \n" ;
02479     echo "n'est pas une matrice, "
.noir("nrow(x)")." renvoie ".noir("NULL").". \n" ;
02480     finp
() ;
02481     
02482     p
("texte") ;
02483     echo "Est-ce un probl&egrave;me&nbsp;? \n" 
;
02484     echo "Oui, mais c'est un peu subtil. Si 
$R \n" ;
02485     echo "affiche bien "
.noir("NULL")." pour ".noir("NULL")." avec ".noir("print()").", concat&eacute;ner ".noir("NULL")." avec quelque chose \n" ;
02486     echo "transforme "
.noir("NULL")." en chaine vide. De m&ecirc;me, utiliser ".noir("NULL")." dans ".noir("cat()")." \n" ;
02487     echo "renvoie aussi la chaine vide, et du coup on ne voit plus rien. \n" 
;
02488     finp
() ;
02489     
02490     p
("texte") ;
02491     echo "Voici avec un exemple pourquoi il est difficile de comprendre ce qui se passe avec un simple "
.noir("print()")."&nbsp;: \n" ;
02492     finp
() ;
02493     
02494     pre_fichier
("bizar05.txt","cadre") ;
02495     
02496     p
("texte") ;
02497     echo "Donc si on ne voit rien avec un "
.hrrr("print")." de notre objet, il faudrait \n" ;
02498     echo "sans doute essayer un "
.noir("print(class(mat))").". Et l&agrave;, miracle ! Voici la partie du code \n" ;
02499     echo "qui a &eacute;t&eacute; l&eacute;g&egrave;rement modifi&eacute; \n" 
;
02500     finp
() ;
02501     
02502     pre_fichier
("bizar07.r","cadre") ;
02503     
02504     p
("texte") ;
02505     echo "et l'affichage de l'ex&eacute;cution : \n" 
;
02506     finp
() ;
02507     
02508     pre_fichier
("bizar06.txt","cadre") ;
02509     
02510     p
("texte") ;
02511     echo "Nous avons donc identifi&eacute; le probl&egrave;me : la variable "
.noir("mat")." change de nature. De \"matrix\" \n" ;
02512     echo "elle passe &agrave; \"integer\", ce qui signifie vecteur d'entiers. Avec un peu plus d'entrainement, \n" 
;
02513     echo "c'&eacute;tait visible puisque 
$R  avait &eacute;crit, avec un seul indice \n" ;
02514     finp
() ;
02515     
02516     pre_fichier
("bizar08.txt","cadre") ;
02517     
02518     p
("texte") ;
02519     echo "au lieu de l'affichage classique des matrices, avec deux s&eacute;ries d'indices&nbsp;: \n" 
;
02520     finp
() ;
02521     
02522     pre_fichier
("bizar09.txt","cadre") ;
02523     
02524     p
("texte") ;
02525     echo "Mais quand on d&eacute;bute en 
$R , on n'est pas expert(e), bien s&ucirc;r et ces subtilit&eacute;s d'affichage nous &eacute;chappent \n" ;
02526     echo "souvent. \n" 
;
02527     finp
() ;
02528     
02529     p
("texte") ;
02530     echo "Nous avons donc identifi&eacute; l'erreur, ou du moins nous avons cern&eacute; le probl&egrave;me. Pour le r&eacute;soudre, \n" 
;
02531     echo "l'aide de "
.hrrr("Extract","","[()")."  et de ".hrrr("drop")." indiquent clairement qu'il faut emp&ecirc;cher $R  de r&eacute;duire la dimension \n" ;
02532     echo "&agrave; l'aide du param&egrave;tre "
.noir("drop").". \n" ;
02533     finp
() ;
02534     
02535     p
("texte") ;
02536     echo "Donc en &eacute;crivant dans notre code \n" 
;
02537     finp
() ;
02538     
02539     pre_fichier
("bizar11.r","cadre") ;
02540     
02541     p
("texte") ;
02542     echo "le probl&egrave;me est r&eacute;solu. Ouf&nbsp;! \n" 
;
02543     finp
() ;
02544     
02545     p
("texte") ;
02546     echo "Enfin, presque... comme souvent en programmation. Car du coup notre boucle... boucle ! \n" 
;
02547     echo "Il faut donc pr&eacute;voir d'arr&ecirc;ter de demander &agrave; supprimer des lignes ou des colonnes s'il n'y en a \n" 
;
02548     echo "plus, soit le code suivant juste avant la fin de la boucle tant que : \n" 
;
02549     finp
() ;
02550     
02551     pre_fichier
("bizar12.r","cadre") ;
02552     
02553     
02554     finblockquote
() ;
02555     
02556     #######################################################################################################################
02557     
02558     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # D&eacute;boggage
02559     
02560     ## -------------------------------------------------------------------------------------------
02561     
02562     blockquote
() ;
02563     
02564     p
("texte") ;
02565     echo "Ce que nous venons de faire est un peu du \"bricolage\" : pour trouver ce qui ne va pas, nous avons \n" 
;
02566     echo "ajout&eacute; des "
.noir("print()")." et nous avons r&eacute;ex&eacute;cut&eacute; le programme. \n" ;
02567     echo "
$R  dispose d'outils beaucoup plus professionnels pour suivre le comportement des fonctions. \n" ;
02568     finp
() ;
02569     
02570     p
("texte") ;
02571     echo "La premi&egrave;re fonction utile &agrave; ce sujet est sans doute "
.hrrr("browser")." --&nbsp;&agrave; ne pas confondre \n" ;
02572     echo "avec la fonction  "
.hrrr("browseURL","utils")." qui affiche une URL dans le navigateur. Mettre ".noir("browser()")." \n" ;
02573     echo "dans le corps d'une fonction permet d'interrompre momentan&eacute;ment l'ex&eacute;cution de la fonction en cours \n" 
;
02574     echo "tout en ayant acc&egrave;s &agrave; 
$R . On peut donc taper des commandes, interroger les variables ou les modifier... \n" ;
02575     finp
() ;
02576     
02577     p
("texte") ;
02578     echo "Lorsque 
$R  ex&eacute;cute ".noir("browser()").", le prompt est modifi&eacute; et affiche ".noir("Browse[n]").". \n" ;
02579     echo "Diff&eacute;rentes commandes sont ajout&eacute;es &agrave; l'environnement habituel de 
$R. Ainsi \n" ;
02580     echo ""
.noir("n")." ex&eacute;cute juste une instruction, \n" ;
02581     echo ""
.noir("c")." quitte ce browser et reprend l'ex&eacute;cution de la fonction en cours &agrave; l'instruction suivante dans la fonction, \n" ;
02582     echo ""
.noir("f")." permet de terminer la boucle courante ou la fonction, \n" ;
02583     echo ""
.noir("Q")." quitte le browser et la fonction. \n" ;
02584     finp
() ;
02585     
02586     p
("texte") ;
02587     echo "Pour &eacute;viter d'avoir &agrave; ajouter "
.noir("browser()")." dans le code puis de l'enlever quand tout va bien -- il est sans doute \n" ;
02588     echo "plus prudent de le mettre en commentaire et de le d&eacute;commenter pour le r&eacute;utiliser au prochain \"bug\" -- 
$R  fournit \n" ;
02589     echo "les fonctions "
.hrrr("debug")." et ".hrrr("debug","","undebug").". Ecrire ".noir("debug(f)")." ex&eacute;cute syst&eacute;matiquement ".noir("browser()")." \n" ;
02590     echo "d&egrave;s que la fonction "
.noir("f")." est appel&eacute;e. ".noir("undebug(f)")." vient annuler ce comportement. On peut se dispenser \n" ;
02591     echo "d'ex&eacute;cuter "
.noir("undebug(f)")." si la fonction ".noir("f")." est red&eacute;finie, par exemple si on lit son code dans un fichier... \n" ;
02592     finp
() ;
02593     
02594     p
("texte") ;
02595     echo "Pour bien comprendre comment tout cela fonctionne, supposons que la boucle "
.bleu("\"TANT QUE\"")." de notre exemple pr&eacute;c&eacute;dent \n" ;
02596     echo "soit dans la fonction "
.noir("gereMatrice").", la matrice &eacute;tant pass&eacute;e en param&egrave;tre. \n" ;
02597     finp
() ;
02598     
02599     p
("texte") ;
02600     echo "Voici donc le code &agrave; d&eacute;panner&nbsp;: \n" 
;
02601     finp
() ;
02602     
02603     pre_fichier
("bizar14.r","cadre") ;
02604     
02605     p
("texte") ;
02606     echo "L'encadr&eacute; suivant montre un exemple de session interactive qui permet de suivre ce que fait 
$R \n" ;
02607     echo "au niveau du d&eacute;boggage \n" 
;
02608     echo "(nous avons juste am&eacute;nag&eacute; un peu le texte). On commence par indiquer &agrave; 
$R \n" ;
02609     echo "qu'on veut d&eacute;bugger notre fonction : \n" 
;
02610     finp
() ;
02611     
02612     pre_fichier
("bizar15.txt","cadre") ;
02613     
02614     p
("texte") ;
02615     echo "On utilise ensuite "
.noir("n")." pour avancer dans l'ex&eacute;cution de la fonction. \n" ;
02616     echo "
$R  affiche chaque instruction avant de l'ex&eacute;cuter. Ici, nous avons appuy&eacute; 5 \n" ;
02617     echo "fois sur "
.noir("n").", pour arriver &agrave; l'int&eacute;rieur de la boucle : \n" ;
02618     finp
() ;
02619     
02620     pre_fichier
("bizar16.txt","cadre") ;
02621     
02622     p
("texte") ;
02623     echo "Nous continuons l'ex&eacute;cution de la fonction avec des "
.noir("n")." successifs, pour arriver juste avant \n" ;
02624     echo "l'ex&eacute;cution du code qui supprime une ligne ou une colonne&nbsp;: \n" 
;
02625     finp
() ;
02626     
02627     pre_fichier
("bizar17.txt","cadre") ;
02628     
02629     p
("texte") ;
02630     echo "Maintenant, interrogeons nos divers objets, ex&eacute;cutons la suppression et regardons la classe et le \n" 
;
02631     echo "contenu de la matrice&nbsp;: \n" 
;
02632     finp
() ;
02633     
02634     pre_fichier
("bizar18.txt","cadre") ;
02635     
02636     p
("texte") ;
02637     echo "C'est fini, nous avons bien localis&eacute; l'endroit o&ugrave; 
$R  change la matrice. Il reste &agrave; taper ".noir("Q")." \n" ;
02638     echo "puis "
.noir("undebug(gereMatrice)")." pour revenir &agrave; un comportement \"normal\" de $R  : \n" ;
02639     finp
() ;
02640     
02641     pre_fichier
("bizar19.txt","cadre") ;
02642     
02643     p
("texte") ;
02644     echo "Il ne faut pas h&eacute;siter &agrave; recourir &agrave; la fonction "
.hrrr("debug")." car c'est un outil tr&egrave;s pratique \n" ;
02645     echo "qui permet de localiser les erreurs. De plus, 
$rstudio \n" ;
02646     echo "fournit un environnement adapt&eacute; &agrave; "
.noir("debug()")." avec des boutons pour les actions \n" ;
02647     echo ""
.noir("c").", ".noir("n")."... et le panneau de droite montre les variables locales... \n" ;
02648     echo "A l'usage, c'est beaucoup plus complet et beaucoup plus pratique que le mode session de l'interface \n" 
;
02649     echo "standard de 
$R. \n" ;
02650     finp
() ;
02651     
02652     finblockquote
() ;
02653     
02654     #######################################################################################################################
02655     
02656     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Ecrire &lt;&lt;- n'est pas une faute de frappe
02657     
02658     ## -------------------------------------------------------------------------------------------
02659     
02660     blockquote
() ;
02661     
02662     p
("texte") ;
02663     echo "Il arrive parfois les programmes soient longs &agrave; s'ex&eacute;cuter et nous essaierons de g&eacute;rer ce \n" 
;
02664     echo "probl&egrave;me dans la section suivante. Il arrive aussi qu'un programme s'ex&eacute;cute sans erreur apparente mais avec \n" 
;
02665     echo "un r&eacute;sultat faux au bout du compte. Pour peu qu'il y ait beaucoup de r&eacute;sultats interm&eacute;diaires, ou beaucoup \n" 
;
02666     echo "de variables et beaucoup de fonctions, la technique pr&eacute;c&eacute;dente avec "
.noir("debug()")." et ".noir("browser")." est parfois un peu \n" ;
02667     echo "\"lourde\" &agrave; utiliser, en particulier parce qu'il s'agit d'un environnement local. Une fois "
.noir("debug()")." quitt&eacute;, les \n" ;
02668     echo "variables locales utilis&eacute;es par la fonction ont disparu. \n" 
;
02669     finp
() ;
02670     
02671     p
("texte") ;
02672     echo "
$R  fournit avec l'instruction ".noir("&lt;&lt;-")." un moyen int&eacute;ressant de \"sauvegarder\" des variables. \n" ;
02673     finp
() ;
02674     
02675     p
("texte") ;
02676     echo "Mais commen&ccedil;ons par regarder cette disparition des variables. \n" 
;
02677     echo "Par d&eacute;faut, toute variable dans une fonction est locale, ce qu'on peut voir avec le code suivant \n" 
;
02678     finp
() ;
02679     
02680     pre_fichier
("vars01.r","cadre") ;
02681     
02682     p
("texte") ;
02683     echo "dont l'ex&eacute;cution fournit : \n" 
;
02684     finp
() ;
02685     
02686     pre_fichier
("vars01.txt","cadre") ;
02687     
02688     p
("texte") ;
02689     echo "Une fonction l'ex&eacute;cution termin&eacute;e, on n'a plus acc&egrave;s aux variables d&eacute;finies dans la fonction. \n" 
;
02690     echo "Si on &eacute;crit  "
.noir("&lt;&lt;-")." au lieu de  ".noir("&lt;-").", $R  vient &eacute;crire la variable dans l'environnement \n" ;
02691     echo "parent donc pour nous ici dans l'environnement global. Ainsi avec \n" 
;
02692     finp
() ;
02693     
02694     pre_fichier
("vars02.r","cadre") ;
02695     
02696     p
("texte") ;
02697     echo "on obtient : \n" 
;
02698     finp
() ;
02699     
02700     pre_fichier
("vars02.txt","cadre") ;
02701     
02702     p
("texte") ;
02703     echo "Il est clair que pour notre exemple, cela ne sert pas &agrave; grand-chose. Pour un exemple en vraie grandeur, \n" 
;
02704     echo "utiliser "
.noir("&lt;&lt;-")." dans le corps de la fonction, ou m&ecirc;me &agrave; l'int&eacute;rieur de ".noir("debug()")." \n" ;
02705     echo "peut permettre de sauvegarder les \"grosses\" variables (listes nomm&eacute;es, data frame construits progressivement...) \n" 
;
02706     echo "dans diff&eacute;rents &eacute;tats au cours de l'ex&eacute;cution afin de pouvoir comparer apr&egrave;s coup les structures, \n" 
;
02707     echo "ou m&ecirc;me simplement pour \n" 
;
02708     echo "documenter ce qui se passe en \n" 
;
02709     echo "d&eacute;but, en cours et en fin d'ex&eacute;cution... \n" 
;
02710     finp
() ;
02711     
02712     finblockquote
() ;
02713     
02714     #######################################################################################################################
02715     
02716     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Profilage
02717     
02718     ## -------------------------------------------------------------------------------------------
02719     
02720     blockquote
() ;
02721     
02722     p
("texte") ;
02723     echo "Une fois que les programmes sont justes et qu'il s'ex&eacute;cutent \"bien\", on peut vouloir \n" 
;
02724     echo "qu'ils s'ex&eacute;cutent \"vite\". Mais d'o&ugrave; vient la lenteur de notre code&nbsp;? \n" 
;
02725     finp
() ;
02726     
02727     p
("texte") ;
02728     echo "Imaginons qu'on ait deux fonctions appel&eacute;es &agrave; l'int&eacute;rieur d'un programme. La lenteur \n" 
;
02729     echo "vient peut-&ecirc;tre de la premi&egrave;re fonction, ou de la deuxi&egrave;me ou peut-&ecirc;tre m&ecirc;me \n" 
;
02730     echo "des autres parties du programme. Pour tester cela, 
$R  fournit en standard plusieurs fonctions, \n" ;
02731     echo "dont "
.hrrr("Rprof","utils")." et ".hrrr("summaryRprof","utils").". \n" ;
02732     finp
() ;
02733     
02734     p
("texte") ;
02735     echo "Voici comment les utiliser : on lance "
.noir("Rprof()").", on ex&eacute;cute le code et ensuite \n" ;
02736     echo "on demande &agrave; 
$R  via ".noir("summaryRprof()")." d'afficher les r&eacute;sultats du profilage. \n" ;
02737     finp
() ;
02738     
02739     p
("texte") ;
02740     echo "Imaginons par exemple qu'une fonction "
.noir("h()")." \n" ;
02741     echo "appelle la fonction "
.noir("f()")." \n" ;
02742     echo "et \n" 
;
02743     echo "la fonction "
.noir("g()").", comme dans le code du fichier \n" ;
02744     echo href
("lent01.r")." suivant \n" ;
02745     finp
() ;
02746     
02747     pre_fichier
("lent01.r","cadre") ;
02748     
02749     p
("texte") ;
02750     echo "Voici le code &agrave; utiliser pour analyser notre fonction "
.noir("h()")." \n" ;
02751     finp
() ;
02752     
02753     pre_fichier
("lent02.r","cadre") ;
02754     
02755     p
("texte") ;
02756     echo "Et son r&eacute;sultat sachant que les dur&eacute;es sont exprim&eacute;es en secondes&nbsp;: \n" 
;
02757     finp
() ;
02758     
02759     pre_fichier
("lent02.txt","cadre") ;
02760     
02761     p
("texte") ;
02762     echo "Les quatre derni&egrave;res lignes de l'affichage de "
.noir("\$by.total")." \n" ;
02763     echo "montrent clairement que les fonctions \n" 
;
02764     echo ""
.noir("f()")." et \n" ;
02765     echo ""
.noir("c()")." \n" ;
02766     echo "prennent beaucoup plus de temps &agrave; s'ex&eacute;cuter que les fonctions \n" 
;
02767     echo ""
.noir("+()")." et \n" ;
02768     echo ""
.noir("g()").". \n" ;
02769     finp
() ;
02770     
02771     p
("texte") ;
02772     echo "Pour tester plus finement du code, on peut utiliser le package nomm&eacute; \n" 
;
02773     echo hrrp
("microbenchmark").". Par exemple, est-il plus rapide de g&eacute;n&eacute;rer un vecteur \n" ;
02774     echo "de valeurs num&eacute;riques suivant une loi uniforme ou une loi normale&nbsp;? \n" 
;
02775     echo "Voici le code qui donne la r&eacute;ponse (il est plus lent de g&eacute;n&eacute;rer des donn&eacute;es normales), avec son ex&eacute;cution&nbsp;: \n" 
;
02776     finp
() ;
02777     
02778     pre_fichier
("microb01.txt","cadre") ;
02779     
02780     p
("texte") ;
02781     echo "De m&ecirc;me, nous avions &eacute;crit qu'il vaut mieux &eacute;viter de r&eacute;aliser \n" 
;
02782     echo "le m&ecirc;me appel de fonction si les param&egrave;tres ne changent pas. Voici \n" 
;
02783     echo "un exemple chronom&eacute;tr&eacute; de ce que cela signifie. \n" 
;
02784     finp
() ;
02785     
02786     p
("texte") ;
02787     echo "Soit le code 
$R  suivant &agrave; &eacute;valuer&nbsp;: \n" ;
02788     finp
() ;
02789     
02790     pre_fichier
("microb02.r","cadre") ;
02791     
02792     p
("texte") ;
02793     echo "Pour comprendre qu'il ne s'agit que d'une &eacute;valuation du temps pass&eacute;, voici deux \n" 
;
02794     echo "ex&eacute;cutions de ce programme : \n" 
;
02795     finp
() ;
02796     
02797     pre_fichier
("microb02.txt","cadre") ;
02798     
02799     p
("texte") ;
02800     echo "A la lecture de ces r&eacute;sultats, la fonction "
.noir("f")." est bien plus lente que la fonction ".noir("g")."&nbsp;: \n" ;
02801     echo "il ne faut donc pas calculer plusieurs fois \n" 
;
02802     echo ""
.noir("max(v)")." mais bien mettre cette valeur dans une variable comme ".noir("maxv").". \n" ;
02803     finp
() ;
02804     
02805     p
("texte") ;
02806     echo "On peut aussi vouloir s'int&eacute;resser non pas aux fonctions mais aux lignes de code. \n" 
;
02807     echo "Le package "
.bleu("lineprof")." permet un tel profilage et fournit un affichage adapt&eacute;. \n" ;
02808     finp
() ;
02809     
02810     p
("texte") ;
02811     echo rouge
("Attention&nbsp;").": ce package n'est pas \n" ;
02812     echo "disponible directement via le "
.href("https://cran.r-project.org/","CRAN")." mais via ".href("https://github.com","github")." seulement. \n" ;
02813     echo " Il utilise le package "
.hrrp("shiny")." pour un affichage interactif dans le navigateur. \n" ;
02814     finp
() ;
02815     
02816     p
("texte") ;
02817     echo "Pour installer ce package "
.bleu("lineprof").", il faut \n" ;
02818     echo "&eacute;crire (sous r&eacute;serve, donc, que le package "
.hrrp("devtools")." soit install&eacute; au pr&eacute;alable)&nbsp;: \n" ;
02819     finp
() ;
02820     
02821     pre_fichier
("lineprof01.txt","cadre") ;
02822     
02823     p
("texte") ;
02824     echo "Admettons par exemple que l'on veuille analyser les lignes du code suivant&nbsp;: \n" 
;
02825     finp
() ;
02826     
02827     pre_fichier
("lent04.r","cadre") ;
02828     
02829     p
("texte") ;
02830     echo "Pour cela, on &eacute;crit \n" 
;
02831     finp
() ;
02832     
02833     pre_fichier
("lineprof01.r","cadre") ;
02834     
02835     p
("texte") ;
02836     echo "Et on obtient dans le navigateur par d&eacute;faut&nbsp;: \n" 
;
02837     finp
() ;
02838     
02839     $img 
"lineprof.png" ;
02840     p
() ;
02841     echo href
($img,img($img)) ;
02842     finp
() ;
02843     
02844     p
("texte") ;
02845     echo "Il est facile de voir que la ligne 8 est la plus \"consommatrice\". \n" 
;
02846     finp
() ;
02847     
02848     finblockquote
() ;
02849     
02850     #######################################################################################################################
02851     
02852     $tdmCRLM8
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Optimisation
02853     
02854     ## -------------------------------------------------------------------------------------------
02855     
02856     blockquote
() ;
02857     
02858     p
("texte") ;
02859     echo "Maintenant que nous savons quelle partie de code est lente, \n" 
;
02860     echo "comment aller plus vite ? \n" 
;
02861     finp
() ;
02862     
02863     p
("texte") ;
02864     echo "C'est une question compliqu&eacute;e car il est possible que la m&eacute;thode soit lente&nbsp;: si vous \n" 
;
02865     echo "avez d&eacute;cid&eacute;, par exemple, de passer en revue toutes les sous-chaines de caract&egrave;res d'un g&eacute;nome humain, ce \n" 
;
02866     echo "sera forc&eacute;ment assez long, disons plusieurs dizaines de minutes sans doute. \n" 
;
02867     finp
() ;
02868     
02869     p
("texte") ;
02870     echo "Donc nous allons supposer que le code est \"bon\" mais lent. Une fois rep&eacute;r&eacute;es les parties vraiment \n" 
;
02871     echo "lentes gr&acirc;ce &agrave; la section pr&eacute;c&eacute;dente, il faut essayer d'appliquer \n" 
;
02872     echo "quelques grands principes pour &eacute;viter qu'un code ne soit lent.  Si ce n'est pas suffisant, \n" 
;
02873     echo "il faudra analyser si la lenteur vient du langage, en interne, ou si cela vient de notre fa&ccedil;on de coder. \n" 
;
02874     finp
() ;
02875     
02876     p
("texte") ;
02877     echo "Tout d'abord, comme nous \n" 
;
02878     echo "venons de le voir, un premier grand principe est qu'il ne faut pas \n" 
;
02879     echo "effectuer deux fois le m&ecirc;me calcul d&eacute;terministe sur une structure si elle \n" 
;
02880     echo "ne change pas. \n" 
;
02881     finp
() ;
02882     
02883     p
("texte") ;
02884     echo "Donc si on utilise une boucle "
.bleu("POUR").", par exemple, il faut enlever tous les \n" ;
02885     echo "calculs comme "
.noir("3*h")." si ".noir("h")." ne d&eacute;pend pas de l'indice de boucle... \n" ;
02886     finp
() ;
02887     
02888     p
("texte") ;
02889     echo "Ensuite, il faut essayer d'utiliser les fonctions vectorielles de 
$R  plut&ocirc;t que \n" ;
02890     echo "de r&eacute;&eacute;crire soi-m&ecirc;me les calculs. \n" 
;
02891     finp
() ;
02892     
02893     p
("texte") ;
02894     echo "Voici par exemple pourquoi il ne faut pas \n" 
;
02895     echo "r&eacute;inventer la somme d'un vecteur&nbsp;: \n" 
;
02896     finp
() ;
02897     
02898     pre_fichier
("sum01.txt","cadre") ;
02899     
02900     p
("texte") ;
02901     echo "Un deuxi&egrave;me grand principe est qu'il ne faut pas laisser 
$R  g&eacute;rer la m&eacute;moire. \n" ;
02902     echo "Malheureusement, ce n'est pas toujours facile de savoir quand 
$R  recopie les variables en m&eacute;moire. \n" ;
02903     echo "Disons, pour simplifier, qu'il est prudent de pr&eacute;voir au maximum les tailles des \n" 
;
02904     echo "tableaux r&eacute;sultats, de les initialiser et ensuite de les remplir. " 
;
02905     finp
() ;
02906     
02907     p
("texte") ;
02908     echo " Imaginons par exemple \n" 
;
02909     echo "que l'on veuille calculer "
.b("n")." nombres \"simples\", par exemple tous les nombres de 1 &agrave; ".noir("n").". \n" ;
02910     finp
() ;
02911     
02912     p
("texte") ;
02913     echo "Si vous &eacute;crivez cela en concat&eacute;nant chaque nouveau nombre au vecteur pr&eacute;c&eacute;dent des r&eacute;sultats, soit le code \n" 
;
02914     finp
() ;
02915     
02916     pre_fichier
("de1an01.r","cadre") ;
02917     
02918     p
("texte") ;
02919     echo "alors 
$R  viendra de temps en temps ou peut-&ecirc;tre m&ecirc;me &agrave; chaque fois recopier le vecteur ".noir("v")." \n" ;
02920     echo "en m&eacute;moire. Il est beaucoup plus efficace de pr&eacute;voir un vecteur de la \"bonne taille\" (voir l'exercice \n" 
;
02921     echo "3 associ&eacute; &agrave; cette page qui explicite les strat&eacute;gies possibles lorsqu'il n'est pas possible de pr&eacute;voir avant l'ex&eacute;cution \n" 
;
02922     echo "la taille des r&eacute;sultats) et de le remplir au fur et &agrave; mesure, soit le code&nbsp;: \n" 
;
02923     finp
() ;
02924     
02925     pre_fichier
("de1an02.r","cadre") ;
02926     
02927     p
("texte") ;
02928     echo "Mais de toutes fa&ccedil;ons ce ne sera jamais aussi efficace que le code 
$R  natif et vectoriel&nbsp;: \n" ;
02929     finp
() ;
02930     
02931     pre_fichier
("de1an03.r","cadre") ;
02932     
02933     p
("texte") ;
02934     echo "En voici la preuve, avec une machine qui a beaucoup de m&eacute;moire. Nous avons pris la pr&eacute;caution \n" 
;
02935     echo "de v&eacute;rifier que l'ordre des instructions ne perturbe pas les r&eacute;sultats (&agrave; cause des \n" 
;
02936     echo "encombrements m&eacute;moire successifs)&nbsp;: \n" 
;
02937     finp
() ;
02938     
02939     pre_fichier
("de1an04.txt","cadre") ;
02940     
02941     finblockquote
() ;
02942     
02943     #######################################################################################################################
02944     #
02945     # progic9
02946     #
02947     #######################################################################################################################
02948     
02949     $numcours 
partie($numcours) ; pvide() ;
02950     $rubrique  
;
02951     $rubriques9 
= array() ;
02952     $rubrique
++ ; $rubriques9[$rubrique] = "Programmation, choix, tests, d&eacute;boggage et profilage " ;
02953     $rubrique
++ ; $rubriques9[$rubrique] = "Programmation, sp&eacute;cifications et documentations" ;
02954     $rubrique
++ ; $rubriques9[$rubrique] = "Mises &agrave; jour, maintenances, objets et packages" ;
02955     $rubrique
++ ; $rubriques9[$rubrique] = "Programmation et Interfa&ccedil;age " ;
02956     $rubrique
++ ; $rubriques9[$rubrique] = "Conclusion" ;
02957     
02958     $tdmCRLM9 
= new tdm($rubriques9) ;
02959     $tdmCRLM9
->titre() ;
02960     $tdmCRLM9
->menu("oui","oui","nou","p$numcours") ;
02961     
02962     # exercices($numcours) ;
02963     
02964     $numRub 
;
02965     
02966     #######################################################################################################################
02967     
02968     $tdmCRLM9
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Programmation, choix, tests, d&eacute;boggage et profilage
02969     
02970     ## -------------------------------------------------------------------------------------------
02971     
02972     blockquote
() ;
02973     
02974     p
("texte") ;
02975     echo "Programmer, c'est &eacute;crire des programmes. Soit. Mais comment &ecirc;tre s&ucirc;r que les programmes sont justes&nbsp;?" 
;
02976     echo " Et que les autres sauront les utiliser&nbsp;?" 
;
02977     echo " Apr&egrave;s r&eacute;flexion, ce n'est pas si simple... " 
;
02978     finp
() ;
02979     
02980     p
("texte") ;
02981     echo "Prenons un exemple concret, celui de la  conversion de et vers des pouces en cm&nbsp;: une fois que l'on sait " 
;
02982     echo "qu'"
.b("un pouce fait 2,54&nbsp;cm").", tout n'est pas dit. Ainsi, comment entrer les valeurs et l'unit&eacute;&nbsp;?" ;
02983     echo " Faut-il &eacute;crire une fonction qui pose une question, lit la r&eacute;ponse au clavier en session 
$R, ou passer ces valeurs " ;
02984     echo " en param&egrave;tres, ou utiliser un formulaire Tcl/Tk, voire une interface Web&nbsp;?" 
;
02985     finp
() ;
02986     
02987     p
("texte") ;
02988     echo "Admettons un instant que l'on s'en tienne au premier choix, &agrave; savoir la lecture au clavier -- ce qui sans doute pas une bonne " 
;
02989     echo " solution, ce que l'on verra plus loin." 
;
02990     echo " Voici un exemple de programme. Voyez-vous l'erreur de programmation&nbsp;?" 
;
02991     finp
() ;
02992     
02993     pre_fichier
("pouce1.r","cadrebleu") ;
02994     
02995     p
("texte") ;
02996     echo "Une lecture rapide du programme et le test avec un cas \"id&eacute;al\" comme ci-dessous&nbsp;:" 
;
02997     finp
() ;
02998     
02999     pre_fichier
("pouce1.sor","cadrejaune") ;
03000     
03001     p
("texte") ;
03002     echo "ne permet pas de prouver que le programme est juste. Cela montre seulement que si on fournit les bons " 
;
03003     echo " param&egrave;tres (en type et en valeur), le calcul est correct. Oui mais, si on saisit "
.b("pouce")." au lieu de " ;
03004     echo b
("pouces").", c'est-&agrave;-dire sans le ".b("s")." &agrave; la fin, que fait le programme&nbsp;?" ;
03005     echo em
(" Stricto sensu").", ".b("pouce")." et ".b("pouces")." ne sont pas &eacute;gaux donc le programme fait la conversion " ;
03006     echo " dans le mauvais sens. " 
;
03007     finp
() ;
03008     
03009     p
("texte") ;
03010     echo "Une version plus fiable serait donc " 
;
03011     finp
() ;
03012     
03013     pre_fichier
("pouce2.r","cadrebleu") ;
03014     
03015     p
("texte") ;
03016     echo "Maintenant, pourquoi ne tester que l'unit&eacute;&nbsp;? " 
;
03017     echo " Avec un utilisateur press&eacute;, ou le clavier num&eacute;rique d&eacute;sactiv&eacute;, la saisie de la valeur peut &ecirc;tre vide. " 
;
03018     echo " Dans ce cas, la variable valeur contient "
.b("NA")." car la fonction ".hrrr("numeric","","as.numeric()")." ne renvoie pas " ;
03019     echo " d'erreur. " 
;
03020     finp
() ;
03021     
03022     p
("texte") ;
03023     echo "Ecrire un programme juste, c'est &agrave; la fois penser aux erreurs possibles, les d&eacute;tecter et les g&eacute;rer. " 
;
03024     echo " On peut d&eacute;cider de boucler sur la saisie d'une valeur num&eacute;rique ou  quitter le programme d&egrave;s la premi&egrave;re " 
;
03025     echo " saisie si la valeur n'est pas num&eacute;rique... "
.rouge("Programmer, c'est donc faire des choix").". " ;
03026     finp
() ;
03027     
03028     p
("texte") ;
03029     echo "Programmer, c'est aussi "
.b("tester")." les divers cas possibles que l'on a recens&eacute;. C'est pourquoi la " ;
03030     echo " saisie au clavier est une mauvaise solution. Car il faudra taper les r&eacute;ponses &agrave; chaque fois que l'on " 
;
03031     echo " veut v&eacute;rifier que ce qu'on a &eacute;crit est correct. Une solution plus \"propre\" et qui correspond plus &agrave; " 
;
03032     echo " l'esprit de 
$R est de d&eacute;finir une fonction de conversion avec les deux param&egrave;tres&nbsp;:" ;
03033     finp
() ;
03034     
03035     pre_fichier
("pouce3.r","cadrebleu") ;
03036     
03037     
03038     p
("texte") ;
03039     echo "L'int&eacute;r&ecirc;t, c'est que maintenant on peut demander &agrave; 
$R de tester les cas possibles juste en " ;
03040     echo " &eacute;x&eacute;cutant le script suivant&nbsp;:" 
;
03041     finp
() ;
03042     
03043     pre_fichier
("pouce4.r","cadrebleu") ;
03044     
03045     p
("texte") ;
03046     echo "Voici ce qu'on obtient alors&nbsp;:" 
;
03047     finp
() ;
03048     
03049     pre_fichier
("pouce4.res","cadrejaune") ;
03050     
03051     
03052     p
("texte") ;
03053     echo "Si on veut vraiment saisir les informations au clavier, on &eacute;crira une autre fonction " 
;
03054     echo " par exemple, "
.b("saisieConversion()")." qui renvoie les deux valeurs. Du coup, on peut &eacute;crire " ;
03055     echo b
("convPouceCm(&nbsp;saisieConversion()&nbsp;)")." pour ex&eacute;cuter les deux actions&nbsp;" ;
03056     finp
() ;
03057     
03058     pre_fichier
("pouce5.r","cadrebleu") ;
03059     
03060     p
("texte") ;
03061     echo "Au passage, on pourrait am&eacute;liorer la fonction "
.b("convPouceCm()")." en pr&eacute;voyant une unit&eacute; par d&eacute;faut, " ;
03062     echo " un affichage par d&eacute;faut avec deux d&eacute;cimales, le choix de l'affichage ou non, le renvoi du r&eacute;sultat, " 
;
03063     echo " ce qui permettrait de tester le programme avec lui-m&ecirc;me&nbsp;: " 
;
03064     finp
() ;
03065     
03066     pre_fichier
("pouce6.res","cadrebleu") ;
03067     
03068     p
("texte") ;
03069     echo "Lorsque le programme &eacute;crit est d'importance, il est essentiel de pouvoir v&eacute;rifier chaque calcul " 
;
03070     echo " interm&eacute;diaire, de pouvoir suivre le d&eacute;tail &agrave; l'int&eacute;rieur de chaque boucle, ou au contraire, de " 
;
03071     echo " pouvoir tout ex&eacute;cuter jusqu'&agrave; une partie d&eacute;licate. " 
;
03072     echo " De m&ecirc;me, si la vitesse d'ex&eacute;cution du programme est mauvaise, il faut pouvoir analyser le " 
;
03073     echo " comportement du programme, savoir o&ugrave; 
$R &laquo;perd du temps&raquo;, ce qui le ralentit..." ;
03074     echo 
$R et $rstudio disposent de fonctions pour cela, heureusement. " ;
03075     #echo " Voir ".href("progie8.php?solutions=0#tdm1","l'exercice 1 de cette section")." pour plus de d&eacute;tails. " ;
03076     finp
() ;
03077     
03078     finblockquote
() ;
03079     
03080     #######################################################################################################################
03081     
03082     $tdmCRLM9
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Programmation, sp&eacute;cifications et documentations
03083     
03084     ## -------------------------------------------------------------------------------------------
03085     
03086     blockquote
() ;
03087     
03088     p
("texte") ;
03089     echo "Ce que montre la section pr&eacute;c&eacute;dente, c'est qu'il faut bien d&eacute;tailler ce que l'on veut faire, " 
;
03090     echo " bien pr&eacute;ciser les entr&eacute;es, les sorties. Autoriser "
.b("p")." ou ".b("i")." ou ".b("d")." comme " ;
03091     echo " abbr&eacute;viation [internationale] l&eacute;gale de "
.b("pouces")." est sans doute une bonne id&eacute;e car on dit " ;
03092     echo em
("inch")." en anglais et ".em("Daumen")." en allemand. Fournir le code-source de la conversion ou le  " ;
03093     echo " rendre accessible sur Internet c'est offrir la possibilit&eacute; aux autres de le lire et peut-&ecirc;tre vous " 
;
03094     echo " aider &agrave; l'am&eacute;liorer (il vaut mieux alors mettre les commentaires en anglais, malheureusement)." 
;
03095     finp
() ;
03096     
03097     p
("texte") ;
03098     echo "Si on n'&eacute;crit pas une fonction mais un ensemble de fonctions, il est conseill&eacute; de fournir des exemples " 
;
03099     echo " d'utilisation, un petit manuel pour rappeler les options, d&eacute;tailler le format des structures utilis&eacute;es. " 
;
03100     echo " Si cela met en jeu des fichiers de donn&eacute;es, il est d'usage de fournir des exemples de tels fichiers, pour " 
;
03101     echo " qu'une personne qui n'a pas &eacute;crit ces fonctions arrive &agrave; les utiliser et &agrave; comprendre comment elles " 
;
03102     echo " fonctionnent juste &agrave; la lecture de l'aide. " 
;
03103     finp
() ;
03104     
03105     p
("texte") ;
03106     echo "Si c'est encore plus complexe, il faut carr&eacute;ment &eacute;crire un livre pour expliquer tout cela en d&eacute;tail, comme " 
;
03107     echo " par exemple avec ces deux ouvrages&nbsp;:" 
;
03108     finp
() ;
03109     
03110     blockquote
() ;
03111     table
(0,15) ;
03112     
03113     tr
() ;
03114        td
("C") ;
03115          echo href
("http://www.springer.com/life+sciences/evolutionary+%26+developmental+biology/book/978-1-4614-1742-2",img("paradis.jpg","",100)) ;
03116        fintd
() ;
03117        td
() ; fintd() ;
03118        td
("C") ;
03119          echo href
("http://www.springer.com/statistics/life+sciences%2C+medicine+%26+health/book/978-0-387-77239-4",img("hahne.jpg","",100)) ;
03120        fintd
() ;
03121     fintr
() ;
03122     
03123     tr
() ;
03124        td
("C") ;
03125          echo href
("http://www.springer.com/life+sciences/evolutionary+%26+developmental+biology/book/978-1-4614-1742-2","Paradis") ;
03126        fintd
() ;
03127        td
() ; fintd() ;
03128        td
("C") ;
03129           echo href
("http://www.springer.com/statistics/life+sciences%2C+medicine+%26+health/book/978-0-387-77239-4","Hahne") ;
03130        fintd
() ;
03131     fintr
() ;
03132     
03133     fintable
() ;
03134     finblockquote
() ;
03135     
03136     finblockquote
() ;
03137     
03138     #######################################################################################################################
03139     
03140     $tdmCRLM9
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Mises &agrave; jour, maintenances, objets et packages
03141     
03142     ## -------------------------------------------------------------------------------------------
03143     
03144     blockquote
() ;
03145     
03146     p
("texte") ;
03147     echo "Il est fr&eacute;quent qu'on ne pense pas tout de suite &agrave; tout, qu'on vienne ajouter des fonctionnalit&eacute;s au fur et &agrave; " 
;
03148     echo " mesure de l'utilisation des programmes. C'est pourquoi il est important de bien g&eacute;rer les num&eacute;ros de version, " 
;
03149     echo " de noter ce qui change (il faut parfois d&eacute;faire ce qui a &eacute;t&eacute; fait et revenir &agrave; une version ant&eacute;rieure). " 
;
03150     echo " Dans certains cas, notamment quand ce qu'on &eacute;crit d&eacute;pend des packages de 
$R, il faut parfois modifier le code " ;
03151     echo " par ce que 
$R a chang&eacute; ou par ce que le package a chang&eacute;." ;
03152     finp
() ;
03153     
03154     p
("texte") ;
03155     echo "Les tests cit&eacute;s dans la section pr&eacute;c&eacute;dente doivent alors permettre de prouver que malgr&eacute; les changements les "
;
03156     echo " programmes font comme avant et m&ecirc;me plus qu'avant. La r&eacute;trocompatibilit&eacute; et la fiabilit&eacute; sont des " 
;
03157     echo " concepts &agrave; retenir et &agrave; impl&eacute;menter." 
;
03158     finp
() ;
03159     
03160     p
("texte") ;
03161     echo "La maintenance du code peut parfois se limiter &agrave; la traduction des messages dans diff&eacute;rentes langues, &agrave; ajouter des " 
;
03162     echo " param&egrave;tres, mais elle peut parfois &ecirc;tre beaucoup plus lourde, par exemple quand on vient "
.b("factoriser")."  du " ;
03163     echo " code, c'est-&agrave;-dire mettre des parties en commun via des sous-programmes qui couvrent plusieurs cas. " 
;
03164     finp
() ;
03165     
03166     p
("texte") ;
03167     echo "Ces quelques s&eacute;ances d'initiation &agrave; la "
.b("programmation &eacute;lementaire")." ne peuvent pas, bien s&ucirc;r, pr&eacute;senter " ;
03168     echo " des concepts plus techniques comme les objets et l'&eacute;criture de packages. Nous renvoyons pour cela aux exercices " 
;
03169     echo " de cettes section afin d'avoir une petite id&eacute;e de ce que cela met en jeu." 
;
03170     finp
() ;
03171     
03172     finblockquote
() ;
03173     
03174     #######################################################################################################################
03175     
03176     $tdmCRLM9
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Programmation et Interfa&ccedil;age
03177     
03178     ## -------------------------------------------------------------------------------------------
03179     
03180     blockquote
() ;
03181     
03182     p
("texte") ;
03183     echo "La notion d'"
.b("interface")." correspond &agrave; deux choses bien distinctes&nbsp;: les interfaces utilisateurs et " ;
03184     echo " les interfaces de programmation. Dans le premier cas, il s'agit de savoir comment l'utilisateur interagit avec les " 
;
03185     echo " fonctions et les programmes (en ligne de commande, par script, par menus, par panneaux...). " 
;
03186     echo " Dans le second cas, il s'agit de faire dialoguer entre eux les langages, d'appeler du C via R, par exemple, " 
;
03187     echo " ou de demander &agrave; Python ou Ruby d'ex&eacute;cuter du R. On pourra consulter les liens ci-dessous pour voir des " 
;
03188     echo " exemples possibles d'interface de programmation." 
;
03189     finp
() ;
03190     
03191     p
("texte") ;
03192      nbsp
(10) ;
03193      echo hrrp
("Rcpp") ;
03194      nbsp
(10) ;
03195      echo href
("http://rpy.sourceforge.net/","R&nbsp;py2","gvert") ;
03196      nbsp
(10) ;
03197      echo href
("https://sites.google.com/a/ddahl.org/rinruby-users/Home","R&nbsp;in&nbsp;Ruby","grouge") ;
03198     finp
() ;
03199     
03200     p
("texte") ;
03201     echo "Au niveau des interfaces utilisateur, &agrave; part des interfaces g&eacute;n&eacute;rales avec menus comme " 
;
03202     echo href
("https://rkward.kde.org/","Rkward") ;
03203     echo " et " 
;
03204     echo href
("http://www.rcommander.com/","Rcmdr").", " ;
03205     echo 
$R fournit un package nomm&eacute; ".hrrp("tcltk") ;
03206     echo " qui permet de d&eacute;velopper des " 
;
03207     echo href
("http://fr.wikipedia.org/wiki/Interface_graphique","GUI")." et un package nomm&eacute; " ;
03208     echo " "
.hrrp("shiny")." pour d&eacute;finir des interfaces web." ;
03209     echo " Ainsi le code suivant &nbsp;" 
;
03210     finp
() ;
03211     
03212     pre_fichier
("pouceGUI.r","cadrebleu") ;
03213     
03214     p
("texte") ;
03215     echo " fournit une interface graphique minimale (et mal pr&eacute;sent&eacute;e) pour la saisie des deux param&egrave;tres dans la conversion pouces/cm..." 
;
03216     finp
() ;
03217     
03218     p
() ;
03219      nbsp
(10) ;
03220      $img 
"pouceGUI.png" ;
03221      echo href
($img,img($img,"",300)) ;
03222     finp
() ;
03223     
03224     
03225     p
("texte") ;
03226     echo "Pour " 
;
03227     echo " "
.href("https://shiny.rstudio.com/tutorial/","shiny").", on &eacute;crit deux scripts&nbsp;: celui du serveur, " ;
03228     echo " nomm&eacute; "
.b("server.R")." et celui de l'interface, nomm&eacute; ".b("ui.R").". Voir par exemple la d&eacute;monstration " ;
03229     echo " dans la "
.href("https://shiny.rstudio.com/gallery/","gallerie de Shiny") ;
03230     echo " nomm&eacute;e "
.href("https://shiny.rstudio.com/gallery/kmeans-example.html","Iris k-means clustering")."... " ;
03231     finp
() ;
03232     
03233     finblockquote
() ;
03234     
03235     #######################################################################################################################
03236     
03237     $tdmCRLM9
->afficheSousRubrique("p$numcours","oui") ; $numRub++ ; # Conclusion
03238     
03239     ## -------------------------------------------------------------------------------------------
03240     
03241     blockquote
() ;
03242     
03243     p
("texte") ;
03244     echo "Les quelques heures pass&eacute;es &agrave; &eacute;crire des scripts 
$R et &agrave; lire les corrig&eacute;s des exercices " ;
03245     echo " vous auront sans doute convaincu(e) que&nbsp;:" 
;
03246     finp
() ;
03247     
03248     ul
() ;
03249     
03250     debutli
() ;
03251     p
("texte") ;
03252     echo "programmer, c'est "
.bleu("assez facile au d&eacute;but").", pour des petits calculs" ;
03253     echo "&nbsp;;" 
;
03254     finp
() ;
03255     finli
() ;
03256     
03257     debutli
() ;
03258     p
("texte") ;
03259     echo "tout le monde peut programmer, mais "
.rouge("bien programmer est un art") ;
03260     echo "&nbsp;;" 
;
03261     finp
() ;
03262     finli
() ;
03263     
03264     debutli
() ;
03265     p
("texte") ;
03266     echo "programmer demande de la rigueur, de la constance et de l'endurance&nbsp;; " 
;
03267     echo "en d'autres termes, programmer peut se r&eacute;v&eacute;ler fastidieux et devenir " 
;
03268     echo b
("intrins&egrave;quement r&eacute;barbatif")." (pour ne pas dire ch*...)" ;
03269     echo "&nbsp;;" 
;
03270     finp
() ;
03271     finli
() ;
03272     
03273     debutli
() ;
03274     p
("texte") ;
03275     echo " programmer demande de la m&eacute;thode, de la r&eacute;flexion et du temps" 
;
03276     echo "&nbsp;;" 
;
03277     finp
() ;
03278     finli
() ;
03279     
03280     debutli
() ;
03281     p
("texte") ;
03282     echo " programmer peut se r&eacute;v&eacute;ler "
.vert("agr&eacute;able")." car cela fait plaisir d'avoir r&eacute;ussi &agrave; cr&eacute;er " ;
03283     echo " quelque chose qui r&eacute;soud un probl&egrave;me ou qui fait le travail en automatique &agrave; notre place." 
;
03284     finp
() ;
03285     finli
() ;
03286     
03287     finul
() ;
03288     
03289     p
("texte") ;
03290     echo "Alors, un seul mot&nbsp;: tous et toutes &agrave; vos papier et crayon avant de passer au clavier&nbsp;!" 
;
03291     finp
() ;
03292     
03293     finblockquote
() ;
03294     
03295     #######################################################################################################################
03296     
03297     pvide
() ;
03298     p
() ;
03299     echo href
("montresource.php?nomfic=tutrprog.php","Code-source php de cette page. ","orange_stim nou") ;
03300     finp
() ;
03301     
03302     #######################################################################################################################
03303     
03304     finSection
() ;
03305     finPage
() ;
03306     ?>

Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier.

 

 

retour gH    Retour à la page principale de   (gH)