Code-source


00001     <?php     

00002     #   # (gH)   -_-  progie6.php  ;  TimeStamp (unix) : 16 F&eacute;vrier 2015 vers 21:26     

00003          

00004     error_reporting(E_ALL | E_NOTICE | E_STRICT) ;     

00005          

00006     include_once("std7.php") ;     

00007     include_once("progi.php") ;     

00008     include_once("statuno7.php") ;     

00009          

00010     $R = s_span("R","gbleuf") ;     

00011     $numSerie = 6 ;     

00012     debutPageExercices($numSerie) ;     

00013          

00014     ## -------------------------------------------------------------------------------------------     

00015          

00016     p("texte") ;     

00017     echo "" ;     

00018     finp() ;     

00019     debutSection() ;     

00020          

00021     $tableauDesRubriques = array() ;     

00022     $idr = 0 ;     

00023          

00024     $idr++; $tableauDesRubriques[$idr] = "Actions sur une liste de fichiers" ;     

00025     $idr++; $tableauDesRubriques[$idr] = "Transformations dans un data frame" ;     

00026     $idr++; $tableauDesRubriques[$idr] = "Positions dans une structure" ;     

00027     $idr++; $tableauDesRubriques[$idr] = "Barre de progression" ;     

00028     $idr++; $tableauDesRubriques[$idr] = "Documenter la fin de fonction" ;     

00029     $idr++; $tableauDesRubriques[$idr] = "Export de r&eacute;sultats pour publication ou d&eacute;monstration" ;     

00030     $idr++; $tableauDesRubriques[$idr] = "Passer des boucles POUR aux fonctions *APPLY (ou autres)" ;     

00031          

00032     $tdmCRLM = new tdm($tableauDesRubriques) ;     

00033     $tdmCRLM->titre() ;     

00034     $tdmCRLM->menu("oui","oui","nou") ;     

00035          

00036     afficherSolutions($numSerie) ;     

00037          

00038     finSection() ;     

00039          

00040     debutSection() ;     

00041     $numExo = 0 ;     

00042          

00043     ## -------------------------------------------------------------------------------------------     

00044          

00045     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Actions sur une liste de fichiers     

00046          

00047     ## -------------------------------------------------------------------------------------------     

00048          

00049     blockquote() ;     

00050          

00051     blockquote() ;     

00052          

00053     p("texte") ;     

00054     echo "On veut ex&eacute;cuter une m&ecirc;me action sur une s&eacute;rie de fichiers. " ; # par exemple leur appliquer la fonction " ;     

00055     #echo b("process(nomFic)")." qui se contente d'afficher le nom du fichier (texte) et le nombre de lignes du fichier " ;     

00056     #echo " (on renverra ces nombres de lignes en sortie de fonction). " ;     

00057     echo " Comment impl&eacute;menter cela en $R&nbsp;?" ;     

00058     echo " Et avec un affichage comme&nbsp;:" ;     

00059     finp() ;     

00060          

00061     pre_fichier("actfic1.txt","cadre") ;     

00062          

00063     finblockquote() ;     

00064          

00065     solution($numExo,$numSerie) ;     

00066          

00067     p("texte") ;     

00068     echo "Pour ce qui suit, nous allons r&eacute;duire l'action &agrave; ex&eacute;cuter sur le fichier au simple affichage de son nom." ;     

00069     echo " On admettra donc que le traitement d'un fichier est r&eacute;alis&eacute; par la fonction suivante&nbsp;:" ;     

00070     finp() ;     

00071          

00072     pre_fichier("action1.r","cadrebleu") ;     

00073          

00074     p("texte") ;     

00075     echo "Pour traiter une liste de fichiers comme celle indiqu&eacute;e, il pourrait &ecirc;tre tentant d'&eacute;crire une " ;     

00076     echo " boucle POUR &agrave; partir de la liste des fichiers, soit le code &nbsp;:" ;     

00077     finp() ;     

00078          

00079     pre_fichier("action2.r","cadrebleu") ;     

00080          

00081     p("texte") ;     

00082     echo "D'o&ugrave; l'affichage&nbsp;:" ;     

00083     finp() ;     

00084          

00085     pre_fichier("action2.res","cadrejaune") ;     

00086          

00087     p("texte") ;     

00088     echo "Ce n'est certainement pas la seule solution. Elle oblige &agrave; programmer une boucle, alors " ;     

00089     echo " qu'on peut se contenter d'&eacute;crire le code &nbsp;:" ;     

00090     finp() ;     

00091          

00092     pre_fichier("action3.r","cadrebleu") ;     

00093          

00094     p("texte") ;     

00095     echo "dont l'affichage est&nbsp;:" ;     

00096     finp() ;     

00097          

00098     pre_fichier("action3.res","cadrejaune") ;     

00099          

00100     p("texte") ;     

00101     echo "Si maintenant on veut absolument un affichage comme ".b("fichier&nbsp;xx/yy")." il est " ;     

00102     echo " possible d'&eacute;crire, toujours sans boucle&nbsp;:" ;     

00103     finp() ;     

00104          

00105     pre_fichier("action4.r","cadrebleu") ;     

00106          

00107     finsolution() ;     

00108          

00109     finblockquote() ;     

00110          

00111     ## -------------------------------------------------------------------------------------------     

00112          

00113     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Transformations dans un data frame     

00114          

00115     ## -------------------------------------------------------------------------------------------     

00116          

00117     blockquote() ;     

00118          

00119     blockquote() ;     

00120          

00121     p("texte") ;     

00122     echo "Comment fait-on en $R pour convertir des donn&eacute;es dans un data frame&nbsp;?" ;     

00123     echo " Par exemple,  comment convertir les unit&eacute;s am&eacute;ricaines dans le syst&egrave;me m&eacute;trique pour les " ;     

00124     echo " donn&eacute;es ".b("height").", ".b("weight")." et ".b("waist")." des donn&eacute;es " ;     

00125     echo href("diabetes.dar","DIABETES")."&nbsp;?" ;  ;     

00126     finp() ;     

00127          

00128     finblockquote() ;     

00129          

00130     solution($numExo,$numSerie) ;     

00131          

00132     p("texte") ;     

00133     echo "La r&eacute;ponse tient en un seul mot&nbsp;: il s'agit de " ;     

00134     echo lafonction("transform").". Voici ce qu'on pourrait naivement &eacute;crire, si on ne connaissait pas cette fonction&nbsp;:" ;     

00135     finp() ;     

00136          

00137     pre_fichier("transform1.r","cadrebleu") ;     

00138          

00139     p("texte") ;     

00140     echo "Et bien s&ucirc;r la \"bonne\" solution, plus concise avec " ;     

00141     echo lafonction("transform")."&nbsp;:" ;     

00142     finp() ;     

00143          

00144     pre_fichier("transform2.r","cadrebleu") ;     

00145          

00146          

00147     p("texte") ;     

00148     echo "Pour des transformations plus sophistiqu&eacute;es, par exemple si on veut utiliser dans la foul&eacute;e des colonnes tout juste cr&eacute;ees, on peut " ;     

00149     echo " passer par la fonction ".hrrr("mutate","plyr")." du package ".hrrp("plyr")."." ;     

00150     finp() ;     

00151          

00152     finsolution() ;     

00153          

00154     finblockquote() ;     

00155          

00156     ## -------------------------------------------------------------------------------------------     

00157          

00158     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Positions dans une structure     

00159          

00160     ## -------------------------------------------------------------------------------------------     

00161          

00162     blockquote() ;     

00163          

00164     blockquote() ;     

00165          

00166     p("texte") ;     

00167     echo "Quelle est la fa&ccedil;on la plus efficace en $R pour trouver les positions d'&eacute;l&eacute;ments remarquables&nbsp;?" ;     

00168     echo " Par exemple pour trouver les positions du minimum, ou les valeurs plus grandes que la moyenne plus deux &eacute;cart-types&nbsp;?" ;     

00169     finp() ;     

00170          

00171     finblockquote() ;     

00172          

00173     solution($numExo,$numSerie) ;     

00174          

00175     p("texte") ;     

00176     echo "Nous avons d&eacute;j&agrave; vu et expliqu&eacute; ce genre de probl&egrave;me et la r&eacute;ponse est le ".rouge("filtrage vectoriel").". " ;     

00177     echo " Voici par exemple comment compter combien de valeurs sont sup&eacute;rieures &agrave; la moyenne&nbsp;:" ;     

00178     finp() ;     

00179          

00180     pre_fichier("filtrage1.res","cadrejaune") ;     

00181          

00182     finsolution() ;     

00183          

00184     finblockquote() ;     

00185          

00186     ## -------------------------------------------------------------------------------------------     

00187          

00188     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Barre de progression     

00189          

00190     ## -------------------------------------------------------------------------------------------     

00191          

00192     blockquote() ;     

00193          

00194     blockquote() ;     

00195          

00196     p("texte") ;     

00197     echo "Comment impl&eacute;menter une barre de progression en $R&nbsp;?" ;     

00198     finp() ;     

00199          

00200     finblockquote() ;     

00201          

00202     solution($numExo,$numSerie) ;     

00203          

00204     p("texte") ;     

00205     echo "Ceci est un probl&egrave;me simple et classique. Il est donc normal qu'il y ait plusieurs solutions en R " ;     

00206     echo " et il ne faut pas passer de temps &agrave; essayer de programmer cela. " ;     

00207     echo " On pourra s'en " ;     

00208     echo " convaincre &agrave; l'aide de la commande " ;     

00209     echo b('RSiteSearch("progress bar")').". La page Web associ&eacute;e est " ;     

00210     echo href("http://search.r-project.org/cgi-bin/namazu.cgi?query=progress+bar&amp;max=20&amp;result=normal&amp;sort=score&amp;idxname=functions&amp;idxname=vignettes&amp;idxname=views","ici").". " ;     

00211     finp() ;     

00212          

00213     p("texte") ;     

00214     echo "Parmi les dizaines de r&eacute;ponses, nous en retiendrons deux, \n" ;     

00215     echo "celle du package ".hrrp("utils")." nomm&eacute;e ".hrrr("txtProgressBar","utils")." et \n" ;     

00216     echo "celle du package ".hrrp("tcltk")." nomm&eacute;e ".hrrr("tkProgressBar","tcltk").". \n" ;     

00217     finp() ;     

00218          

00219     p("texte") ;     

00220     echo "Prenons tout d'abord quelque chose d'un peu long &agrave; calculer&nbsp;: \n" ;     

00221     finp() ;     

00222          

00223     pre_fichier("progressb01.r","cadre") ;     

00224          

00225     p("texte") ;     

00226     echo "Et voyons comment afficher une barre de progression \n" ;     

00227     echo "sur 50 caract&egrave;res \"&eacute;gal\". Nous commen&ccedil;ons par afficher une ligne d'&eacute;toiles de la \n" ;     

00228     echo "m&ecirc;me longueur que la barre de progression&nbsp;: \n" ;     

00229     finp() ;     

00230          

00231     pre_fichier("progressb02.r","cadre") ;     

00232          

00233     p("texte") ;     

00234     echo "Voici ce qui est affich&eacute; au bout de 10 secondes si on ex&eacute;cute \n" ;     

00235     finp() ;     

00236          

00237     pre_fichier("progressb02.txt","cadre") ;     

00238          

00239     p("texte") ;     

00240     echo "Les barres de progression affich&eacute;es par ".hrrr("tkProgressBar","tcltk")." sont des fen&ecirc;tres &agrave; part et qui n'apparaissent pas \n" ;     

00241     echo "dans la sortie console. En voici un exemple, inspir&eacute;, ".em("bien s&ucirc;r")." de ".b("example(tkProgressBar)")." \n" ;     

00242     echo "sachant que la syntaxe de la fonction  ".hrrr("tkProgressBar","tcltk")." \n" ;     

00243     echo "est tr&egrave;s similaire &agrave; celle de la fonction ".hrrr("txtProgressBar","utils")."&nbsp;: \n" ;     

00244     finp() ;     

00245          

00246     pre_fichier("progress03.r","cadre") ;     

00247          

00248     p("texte") ;     

00249     echo "Voici ce qui est affich&eacute; au bout de 10 secondes&nbsp;:" ;     

00250     finp() ;     

00251          

00252     # \includegraphics[width=14cm]{progress03.png     

00253          

00254     $img = "progress03.png" ;     

00255     p() ;     

00256     nbsp(20) ;     

00257     echo href($img,img($img,"",600)) ;     

00258     finp() ;     

00259          

00260     p("texte") ;     

00261     echo b("Conclusion&nbsp;:")." il y a tr&egrave;s souvent dans les packages $R tout ce qu'on veut comme solution technique \n" ;     

00262     echo "&agrave; un probl&egrave;me classique ou fr&eacute;quent. \n" ;     

00263     finp() ;     

00264          

00265     finsolution() ;     

00266          

00267     finblockquote() ;     

00268          

00269     ## -------------------------------------------------------------------------------------------     

00270          

00271     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Documenter la fin de fonction     

00272          

00273     ## -------------------------------------------------------------------------------------------     

00274          

00275     blockquote() ;     

00276          

00277     blockquote() ;     

00278          

00279     p("texte") ;     

00280     echo "Vous avez d&eacute;j&agrave; vu dans nos codes-source les fins de fonctions \n" ;     

00281     echo "document&eacute;es comme ceci&nbsp;: \n" ;     

00282     finp() ;     

00283          

00284     pre_fichier("finfonc.txt","cadre") ;     

00285          

00286     p("texte") ;     

00287     echo "A quoi cela peut-il servir ? \n" ;     

00288     finp() ;     

00289          

00290     p("texte") ;     

00291     echo "Est-ce simple d'&eacute;crire une fonction qui utilise un param&egrave;tre qui correspond \n" ;     

00292     echo "&agrave; un nom de fichier script au sens de $R et en affiche la liste des fonctions \n" ;     

00293     echo "avec le num&eacute;ro de ligne du d&eacute;but de fonction \n" ;     

00294     echo "comme dans \n" ;     

00295     finp() ;     

00296          

00297     pre_fichier("listefonc.txt","cadre") ;     

00298          

00299     p("texte") ;     

00300     echo " Comment utiliser cette fonction dans le terminal sans passer par Rstudio&nbsp;?" ;     

00301     finp() ;     

00302          

00303     finblockquote() ;     

00304          

00305     solution($numExo,$numSerie) ;     

00306          

00307     p("texte") ;     

00308     echo "Ecrire explicitement ".noir("# fin de fonction").", comme &eacute;crire \n" ;     

00309     echo "".noir("# fin si")." ou \n" ;     

00310     echo "".noir("# fin pour")." \n" ;     

00311     echo "rend le code-source beaucoup plus lisible pour un &ecirc;tre humain (l'interpr&eacute;teur \n" ;     

00312     echo " $R, lui, utilise d'autres r&egrave;gles pour \"lire\" et \"comprendre\" le code). \n" ;     

00313     finp() ;     

00314          

00315     p("texte") ;     

00316     echo "Il est s&ucirc;r que quand on lit un code comme \n" ;     

00317     finp() ;     

00318          

00319     pre_fichier("cmt01.txt","cadre") ;     

00320          

00321     p("texte") ;     

00322     echo "ou \n" ;     

00323     finp() ;     

00324          

00325     pre_fichier("cmt02.txt","cadre") ;     

00326          

00327     p("texte") ;     

00328     echo "on ne sait pas explicitement quelle structure se termine. C'est pourquoi nous vous conseillons \n" ;     

00329     echo "d'&eacute;crire \n" ;     

00330     finp() ;     

00331          

00332     pre_fichier("cmt03.txt","cadre") ;     

00333          

00334     p("texte") ;     

00335     echo "m&ecirc;me si certains &eacute;diteurs de textes sont capables d'auto-indenter le code-source. \n" ;     

00336     finp() ;     

00337          

00338     p("texte") ;     

00339     echo "Documenter la fin de fonction rend aussi plus facile la recherche des fonctions dans un \n" ;     

00340     echo "texte par programme. C'est pourquoi nous &eacute;crivons ".noir("# fin fonction xxx")." et non pas \n" ;     

00341     echo "".noir("# end function").". Cela permet de pouvoir fournir facilement dans une page Web juste le code de la \n" ;     

00342     echo "fonction, comme par exemple pour l'interface de ".b("statghfns")."&nbsp;: \n" ;     

00343     finp() ;     

00344          

00345          

00346     p("texte") ;     

00347     nbsp(15) ;     

00348     echo href("http://forge.info.univ-angers.fr/~gh/wstat/statghfns.php","","bouton_fin nou bleu_pastel") ;     

00349     finp() ;     

00350          

00351     p("texte") ;     

00352     echo "Si on respecte un minimum de convention d'&eacute;criture comme par exemple \n" ;     

00353     echo "mettre le d&eacute;but et la fin de fonction sur une seule ligne, produire une liste des fonctions \n" ;     

00354     echo "comme celle demand&eacute;e consiste juste &agrave; savoir d&eacute;tecter les expressions ".noir("&lt;-&nbsp;function")." \n" ;     

00355     echo "et ".noir("# fin fonction").". \n" ;     

00356     echo "Heureusement, $R dispose de fonctions pour cela. \n" ;     

00357     finp() ;     

00358          

00359     p("texte") ;     

00360     echo "Ainsi, avec la fonction ".hrrr("grep")." du package ".hrrp("base").", on peut facilement trouver les num&eacute;ros de lignes. \n" ;     

00361     finp() ;     

00362          

00363     p("texte") ;     

00364     echo "Il suffit d'&eacute;crire, apr&egrave;s la lecture du fichier par ".noir("lignes &lt;- readLines(fichier)")." \n" ;     

00365     finp() ;     

00366          

00367     pre_fichier("grep01.r","cadre") ;     

00368          

00369     p("texte") ;     

00370     $bs = "\\";     

00371     $pg = "(";     

00372     echo "L'expression r&eacute;guli&egrave;re utilis&eacute;e ici ".noir("\"&lt;-".$bs.$bs."s+function".$bs.$bs."$pg\"")." est un tout petit peu plus compliqu&eacute;e \n" ;     

00373     echo "que la simple chaine ".noir("\"&lt;- function\"")." \n" ;     

00374     echo "car \n" ;     

00375     finp() ;     

00376          

00377     ul() ;     

00378          

00379     debutli() ; p() ;     

00380     echo "il peut y avoir plusieurs espaces entre ".noir("&lt;-")."  et ".noir("function")." \n" ;     

00381     echo "d'o&ugrave; la partie ".noir("\\s+")."&nbsp;; \n" ;     

00382     finp() ; finli() ;     

00383          

00384     debutli() ; p() ;     

00385     echo "pour saisir un \"slash\" dans une expression r&eacute;guli&egrave;re, il faut doubler ce symbole, d'o&ugrave;  ".noir("\\\\s+")."&nbsp;; \n" ;     

00386     finp() ; finli() ;     

00387          

00388     debutli() ; p() ;     

00389     echo "pour saisir une parenth&egrave;se dans une expression r&eacute;guli&egrave;re, il faut la faire pr&eacute;c&eacute;der d'un \"slash\" qui doit lui-m&ecirc;me \n" ;     

00390     echo "&ecirc;tre doubl&eacute; d'o&ugrave; ".noir("\\\\(").". \n" ;     

00391     finp() ; finli() ;     

00392          

00393     finul() ;     

00394          

00395     p("texte") ;     

00396     echo "Si de plus on utilise le param&egrave;tre ".noir("value")." avec la valeur ".noir("TRUE")." dans l'appel de " ;     

00397     echo " la fonction ".hrrr("grep") ;     

00398     echo ", $R renvoie la chaine d&eacute;tect&eacute;e. Voici ce qu'on \n" ;     

00399     echo "peut donc facilement obtenir avec $R juste avec ".noir("grep()")."et l'expression r&eacute;guli&egrave;re&nbsp;: \n" ;     

00400     finp() ;     

00401          

00402     pre_fichier("grep02.txt","cadre") ;     

00403          

00404     p("texte") ;     

00405     echo "Au niveau de la deuxi&egrave;me expression r&eacute;guli&egrave;re, nous avons ajout&eacute; ".noir(".*")." devant ".noir("&lt;-")." afin de r&eacute;cup&eacute;rer le nom de la fonction. \n" ;     

00406     finp() ;     

00407          

00408     p("texte") ;     

00409     echo "Pour terminer l'exercice, il suffit de ne garder que le premier mot de chaque ligne trouv&eacute;e, ce qu'on peut faire avec une fonction \n" ;     

00410     echo "anonyme. Voici donc le texte complet de la fonction qui construit la liste des fonctions d'un fichier-script&nbsp;: \n" ;     

00411     finp() ;     

00412          

00413     pre_fichier("listefonc.r","cadre") ;     

00414          

00415     p("texte") ;     

00416     echo "Le rendu est presque conforme &agrave; ce qu'on voulait \n" ;     

00417     finp() ;     

00418          

00419     pre_fichier("listefonc2.txt","cadre") ;     

00420          

00421     p("texte") ;     

00422     echo "au cadrage pr&egrave;s des num&eacute;ros de ligne &agrave; droite, ce qu'on peut obtenir \n" ;     

00423     echo "facilement avec la fonction ".hrrr("sprintf").". Il manque aussi les parenth&egrave;ses apr&egrave;s le nom des fonctions, ce qu'on r&eacute;alise tr&egrave;s \n" ;     

00424     echo "simplement la fonction ".hrrr("paste").". Donc au lieu du ".noir("print()")." en fin de fonction, si on &eacute;crit \n" ;     

00425     finp() ;     

00426          

00427     pre_fichier("listefonc2.r","cadre") ;     

00428          

00429     p("texte") ;     

00430     echo "alors le r&eacute;sultat est exactement ce qu'on voulait&nbsp;: \n" ;     

00431     finp() ;     

00432          

00433     pre_fichier("listefonc3.txt","cadre") ;     

00434          

00435     p("texte") ;     

00436     echo "Vous aurez remarqu&eacute;, bien s&ucirc;r, qu'il n'y a pas de boucle, car nous n'avons utilis&eacute; que des ".b("fonctions vectorielles").". \n" ;     

00437     finp() ;     

00438          

00439     p("texte") ;     

00440     echo " Pour utiliser cette fonction dans un terminal, il suffit de passer par la commande R ou la commande Rscript. " ;     

00441     echo " Il faut bien sur r&eacute;cup&eacute;rer le param&egrave;tre qui correspond au nom du fichier&nbsp;:" ;     

00442     finp() ;     

00443          

00444     pre_fichier("listefonc4.txt","cadrejaune") ;     

00445          

00446     p() ;     

00447     echo "Fichiers associ&eacute;s&nbsp;: " ;     

00448     echo href("listeDesFonctions.r").snbsp(2) ;     

00449     echo href("listefonc.r").snbsp(2)  ;     

00450     echo href("conversions.r")."." ;     

00451     finp() ;     

00452          

00453     finsolution() ;     

00454          

00455     finblockquote() ;     

00456          

00457     ## -------------------------------------------------------------------------------------------     

00458          

00459     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Export de r&eacute;sultats pour publication ou d&eacute;monstration     

00460          

00461     ## -------------------------------------------------------------------------------------------     

00462          

00463     blockquote() ;     

00464          

00465     blockquote() ;     

00466          

00467     p("texte") ;     

00468     echo "On voudrait produire des calculs en $R et disposer rapidement et de fa&ccedil;on reproductible des " ;     

00469     echo " r&eacute;sultats num&eacute;riques et graphiques sans avoir &agrave; passer par du copier/coller pour produire les " ;     

00470     echo " documents associ&eacute;s. Comment faut-il s'y prendre&nbsp;?" ;     

00471     echo " Et si on a besoin de tirages al&eacute;atoires dans les calculs&nbsp;?" ;     

00472     finp() ;     

00473          

00474     finblockquote() ;     

00475          

00476     solution($numExo,$numSerie) ;     

00477          

00478     p("texte") ;     

00479     echo "Pour produire des r&eacute;sultats reproductibles, il vaut mieux &eacute;viter d'utiliser $R via $rstudio &agrave; cause des " ;     

00480     echo " variables qui pourraient &ecirc;tre dans l'environnement. Il est donc conseill&eacute; d'ex&eacute;cuter $R directement. " ;     

00481     echo " Si on utilise des valeurs al&eacute;atoires, il faut utiliser toujours la m&ecirc;me " ;     

00482     echo hrrr("Random","","graine").". Voici un exemple d'utilisation&nbsp;:" ;     

00483     finp() ;     

00484          

00485     pre_fichier("alea1.res","cadrebleu") ;     

00486          

00487          

00488     p("texte") ;     

00489     echo "En ce qui concerne la production de documents avec les r&eacute;sultats, il est clair que la technique du " ;     

00490     echo b("copier/coller")." n'est pas envisageable, de par le nombre et la r&eacute;p&eacute;tition des manipulations, sans " ;     

00491     echo " compter les risques d'erreur. " ;     

00492     echo " $R fournit de nombreuses solutions pour produire des documents. " ;     

00493     echo href("http://yihui.name/knitr/","knitr")." est sans doute la plus pratique (plut&ocirc;t que " ;     

00494     echo href("https://www.statistik.lmu.de/~leisch/Sweave/","Sweave")."). " ;     

00495     echo " Elle s'int&egrave;gre &agrave; du code LaTeX, HTML ou Markdown." ;     

00496     finp() ;     

00497          

00498     p("texte") ;     

00499     echo "Imaginons par exemple qu'on veuille r&eacute;diger un document qui montre comment tracer la densit&eacute; d'un m&eacute;lange de deux lois normales. " ;     

00500     echo " Voici la fonction ".b("traceNorms()")." du fichier ".href("alea2.r")." qui r&eacute;alise ce trac&eacute;&nbsp;:";     

00501     finp() ;     

00502          

00503     # norm1 <- rnorm(n=5000, mean = -3, sd = 2)     

00504     # norm2 <- rnorm(n=5000, mean = 15, sd = 5)     

00505          

00506     pre_fichier("alea2.r","cadrebleu") ;     

00507          

00508     p("texte") ;     

00509     echo "Voici maintenant le document nomm&eacute; ".href("alea.rnw")." au format " ;     

00510     echo href("http://rug.mnhn.fr/semin-r/PDF/semin-R_knitr_PBessonneau_240513.pdf","knitr")." qui utilise cette fonction&nbsp;:" ;     

00511     finp() ;     

00512          

00513     pre_fichier("alea.rnw","cadrebleu") ;     

00514          

00515     p("texte") ;     

00516     echo " Dans une session $R, il suffit de charger le package ".b("knitr")." puis d'ex&eacute;cuter " ;     

00517     echo " la  seule commande ".b('knit("alea.rnw",encoding="UTF-8")') ;     

00518     echo " pour produire le fichier ".href("alea.tex").". Via la commande " ;     

00519     echo b("pdflatex&nbsp;alea.tex")." on obtient alors le fichier ".href("alea.pdf")."." ;     

00520     echo " Facile, non &nbsp;? " ;     

00521     echo " Oui, si on connait d&eacute;j&agrave; ".href("http://fr.wikibooks.org/wiki/LaTeX","LaTeX")."." ;     

00522     finp() ;     

00523          

00524     p("texte") ;     

00525     echo "Il serait m&ecirc;me possible de cr&eacute;er une page Web pour faire saisir &agrave; l'utilisateur les 5  ";     

00526     echo " param&egrave;tres de la fonction ".b("traceNorms()")." et produire le PDF &agrave; la vol&eacute;e, mais c'est une autre histoire, " ;     

00527     echo " qui met en jeu trois autres langages, &agrave; savoir PHP, HTML et CSS..." ;     

00528     finp() ;     

00529          

00530     p("texte") ;     

00531     echo " Pour avoir rapidement une id&eacute;e des possibilit&eacute;s de Markdown dans $R, le plus simple est d'utiliser Rstudio. " ;     

00532     echo " Si on passe par le menu File/New File/R Markdown et si on sauvegarde les informations fournies, disons dans " ;     

00533     echo " demo.Rmd, alors l'utilisation de l'icone Knit et de ses options HTML/PDF/Word produit les fichiers demand&eacute;s..." ;     

00534     finp() ;     

00535          

00536     table(0,20,"collapse") ;     

00537       tr() ;     

00538         td("C") ;     

00539           nbsp(8) ;     

00540         fintd() ;     

00541         td("C") ;     

00542         $img = "knitr1.png" ;     

00543         echo href($img,img($img,"",300)) ;     

00544         fintd() ;     

00545         td("C") ;     

00546         $img = "knitr2.png" ;     

00547         echo href($img,img($img,"",300)) ;     

00548         fintd() ;     

00549       fintr() ;     

00550     fintable() ;     

00551          

00552          

00553     finsolution() ;     

00554          

00555     finblockquote() ;     

00556          

00557     ## -------------------------------------------------------------------------------------------     

00558          

00559     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Passer des boucles POUR aux fonctions *APPLY     

00560          

00561     ## -------------------------------------------------------------------------------------------     

00562          

00563     blockquote() ;     

00564          

00565     blockquote() ;     

00566          

00567     p("texte") ;     

00568     echo " Le passage en revue des colonnes d'un dataframe se fait facilement avec une boucle POUR, comme ci-dessous. " ;     

00569     finp() ;     

00570          

00571     pre_fichier("revueColonnes1.r","cadrebleu") ;     

00572     pre_fichier("revueColonnes1.sor","cadrejaune") ;     

00573          

00574     p("texte") ;     

00575     echo " Remplacer cette boucle POUR par un appel de la fonction SAPPLY via les indices de colonnes. " ;     

00576     echo " Trouver ensuite comment utiliser SAPPLY avec les noms de colonnes. " ;     

00577     echo " Quel est, hormis la concision, l'int&eacute;r&ecirc;t de passer par des fonctions *APPLY&nbsp;?" ;     

00578     finp() ;     

00579          

00580     p("texte") ;     

00581     echo " Comment produire la matrice triangulaire inf&eacute;rieure d'une matrice sym&eacute;trique&nbsp? " ;     

00582     echo " On pourra utiliser la fonction " ;     

00583     echo hrrr("cor","stats") ;     

00584     echo " ou la fonction " ;     

00585     echo hrrr("dist","stats") ;     

00586     echo " pour g&eacute;n&eacute;rer une telle matrice, comme par exemple&nbsp;:" ;     

00587     finp() ;     

00588          

00589     pre_fichier("cordist.r","cadre") ;     

00590     pre_fichier("cordist.sor","cadrejaune") ;     

00591          

00592     finblockquote() ;     

00593          

00594     solution($numExo,$numSerie) ;     

00595          

00596     p("texte") ;     

00597     echo " Cet exercice semble &ecirc;tre volontairement non corrig&eacute; sur cette page. " ;     

00598     span("nou","","onclick = \"window.document.getElementById('lasol').setAttribute('class','visible') \"") ;     

00599     echo ghBleu(" Quoique...") ;     

00600     finp() ;     

00601          

00602     p("texte") ;     

00603     #echo " En fait, la solution se fait en cliquant sur l'un des mots du paragraphe pr&eacute;c&eacute;dent. Sauriez-vous " ;     

00604     #echo " deviner lequel&nbsp;?" ;     

00605     echo em(" Actually, the solution is available if you click on one the word of the preceding paragraph. ") ;     

00606     echo em(" Can you guess which one it is?") ;     

00607     finp() ;     

00608          

00609     div("invisible","lasol") ;     

00610          

00611     h3("7.1 Passage en revue des colonnes") ;     

00612          

00613     blockquote() ;     

00614          

00615     p("texte") ;     

00616      echo " Avant de passer de cette boucle POUR &agrave; un APPLY, essayons d'analyser ce qui pourrait d&eacute;j&agrave; &ecirc;tre am&eacute;lior&eacute; " ;     

00617      echo" dans le code afin qu'on puisse s'en resservir." ;     

00618     finp() ;     

00619          

00620     p("texte") ;     

00621     echo " Pour gagner en g&eacute;n&eacute;ralit&eacute;, le mieux est d'essayer de d&eacute;finir une fonction et de passer les donn&eacute;es en param&egrave;tre. " ;     

00622     echo " L'int&eacute;r&ecirc;t est qu'on pourra tester et r&eacute;utiliser cette fonction en-dehors de la boucle." ;     

00623     echo " Voici donc une premi&egrave;re tentative, toujours avec la boucle POUR. " ;     

00624     finp() ;     

00625          

00626     pre_fichier("revueColonnes2.r","cadre") ;     

00627     pre_fichier("revueColonnes2.sor","cadrejaune") ;     

00628          

00629     p("texte") ;     

00630     echo " Enfin, une \"vraie\" solution $R consiste &agrave; renvoyer un ".em("data.frame") ;     

00631     echo " car cette structure de donn&eacute;es est adapt&eacute;e &agrave; l'utilisation de " ;     

00632     echo hrrr("apply")." et ".hrrr("lapply","","sapply")." comme on peut le voir ci-dessous&nbsp;" ;     

00633     finp() ;     

00634          

00635     pre_fichier("revueColonnes3.r","cadrebleu") ;     

00636     pre_fichier("revueColonnes3.sor","cadrejaune") ;     

00637          

00638     finblockquote() ;     

00639          

00640     h3("7.2 Matrice triangulaire inf&eacute;rieure") ;     

00641          

00642     blockquote() ;     

00643          

00644     p("texte") ;     

00645     echo " Pour la matrice triangulaire inf&eacute;rieure, une(e) habitu&eacute;(e) des matrices carr&eacute;es de taille ".em("n") ;     

00646     echo " viendra utiliser une boucle POUR de 1 &agrave; ".em("n")." avec un indice ".em("i")." sur les lignes et " ;     

00647     echo " une boucle POUR de 1 &agrave; ".em("i")." sur les colonnes, soit le code&nbsp;:" ;     

00648     finp() ;     

00649          

00650     pre_fichier("triang1.r","cadrebleu") ;     

00651     pre_fichier("triang1.sor","cadrejaune") ;     

00652          

00653     p("texte") ;     

00654     echo " Commen&ccedil;ons par remplacer la boucle la plus interne par une fonction ".b("printLig") ;     

00655     echo " afin de pouvoir utiliser ".b("sapply")." sur les indices de lignes&nbsp;:" ;     

00656     finp() ;     

00657          

00658     pre_fichier("triang2.r","cadrebleu") ;     

00659     pre_fichier("triang2.sor","cadrejaune") ;     

00660          

00661     p("texte") ;     

00662     echo " Il n'est pas difficile d'arranger un peu les sorties de cette fonction &nbsp;:" ;     

00663     finp() ;     

00664          

00665     pre_fichier("triang3.r","cadrebleu") ;     

00666     pre_fichier("triang3.sor","cadrejaune") ;     

00667          

00668     p("texte") ;     

00669     echo " Il suffit maintenant d'utiliser la notation ".b("deux points")." de $R pour &eacute;liminer " ;     

00670     echo " la deuxi&egrave;me boucle POUR " ;     

00671     echo " car la fonction ".b("printLig")  ;     

00672     echo " ne fait qu'appeler la fonction ".hrrr("sprintf")." qui est une fonction ".b("vectorielle") ;     

00673     echo " donc &eacute;liminer cette boucle est facile. " ;     

00674     echo " Du coup, la fonction ".b("printLig")." peut &ecirc;tre remplac&eacute;e " ;     

00675     echo " par une fonction anonyme&nbsp;:" ;     

00676     finp() ;     

00677          

00678     pre_fichier("triang4.r","cadrebleu") ;     

00679     pre_fichier("triang4.sor","cadrejaune") ;     

00680          

00681     p("texte") ;     

00682     echo " On peut bien s&ucirc;r faire mieux et plus court, parce que $R " ;     

00683     echo " dispose de la fonction ".hrrr("lower.tri")." dans le package ".hrrp("base") ;     

00684     echo "&nbsp;:" ;     

00685     finp() ;     

00686          

00687     pre_fichier("triang5.r","cadrebleu") ;     

00688     pre_fichier("triang5.sor","cadrejaune") ;     

00689          

00690     p("texte") ;     

00691     echo " Voici enfin la \"vraie\" solution $R qui ".b("produit")." une matrice triangulaire inf&eacute;rieure, " ;     

00692     echo " avec des noms de lignes et de colonnes, au lieu d'un simple affichage&nbsp;:" ;     

00693     finp() ;     

00694          

00695     pre_fichier("triang6.r","cadrebleu") ;     

00696     pre_fichier("triang6.sor","cadrejaune") ;     

00697          

00698     finblockquote() ;     

00699          

00700     findiv() ;     

00701          

00702     finsolution() ;     

00703          

00704     finblockquote() ;     

00705          

00706     ## -------------------------------------------------------------------------------------------     

00707          

00708     finPageExercices($numSerie) ; # contient finSection() et finPage() ; la fonction est dans progi.php     

00709          

00710     ?>
Listing du fichier progie6.php
