Code-source


00001     <?php     

00002     #    (gH)   -_-  intror2.php  ;  TimeStamp (unix) : 19 Ao&ucirc;t 2013 vers 20:16     

00003          

00004     error_reporting(E_ALL | E_NOTICE | E_STRICT) ;     

00005          

00006     include_once("std7.php") ;     

00007     include_once("intror_inc.php") ;     

00008     include_once("../../statuno.php") ;     

00009          

00010     $numSerie = 2 ;     

00011     debutPageExoScr1($numSerie) ;     

00012          

00013     ## -------------------------------------------------------------------------------------------     

00014          

00015     sdl(3) ; echo cmt(' pour afficher toutes les solutions : intror2.php?solutions=1') ; sdl(3) ;     

00016          

00017     ## -------------------------------------------------------------------------------------------     

00018          

00019     p("texte") ;     

00020     echo "" ;     

00021     finp() ;     

00022     debutSection() ;     

00023          

00024     $tableauDesRubriques = array() ;     

00025     $idr = 0 ;     

00026     $idr++; $tableauDesRubriques[$idr] = "R&eacute;pertoires, scripts et fonctions (gH)" ;     

00027     $idr++; $tableauDesRubriques[$idr] = "Lecture de fichiers textes, bureautique et gestion des accents" ;     

00028     $idr++; $tableauDesRubriques[$idr] = "Listes en $R" ;     

00029     $idr++; $tableauDesRubriques[$idr] = "Variables quantitatives et qualitatives" ;     

00030     $idr++; $tableauDesRubriques[$idr] = "R&eacute;cup&eacute;ration de tableaux $HTML" ;     

00031     $idr++; $tableauDesRubriques[$idr] = "Regroupement et fusion de donn&eacute;es" ;     

00032     $idr++; $tableauDesRubriques[$idr] = "Indi&ccedil;age, filtrage et s&eacute;lection de donn&eacute;es" ;     

00033     $idr++; $tableauDesRubriques[$idr] = "Conversion de structures de donn&eacute;es en $R" ;     

00034     $idr++; $tableauDesRubriques[$idr] = "Gestion des donn&eacute;es manquantes" ;     

00035     $idr++; $tableauDesRubriques[$idr] = "Export de donn&eacute;es en $HTML et $LaTeX" ;     

00036     $idr++; $tableauDesRubriques[$idr] = "$R et SQL" ;     

00037     $idr++; $tableauDesRubriques[$idr] = "Non pr&eacute;sentation (!) des packages base, gdata, tools, foreign et utils" ;     

00038     $tdmCRLM = new tdm($tableauDesRubriques) ;     

00039     $tdmCRLM->titre() ;     

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

00041          

00042     pvide() ;     

00043          

00044     p() ;     

00045      echo "Il est possible d'afficher toutes les solutions via ".href("intror2.php?solutions=1","?solutions=1","bouton_fin jaune_pastel nou").". " ;     

00046     finp() ;     

00047          

00048     finSection() ;     

00049          

00050     debutSection() ;     

00051     $numExo = 0 ;     

00052          

00053     ## -------------------------------------------------------------------------------------------     

00054          

00055     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # R&eacute;pertoires, scripts et fonctions (gH)     

00056          

00057     ## -------------------------------------------------------------------------------------------     

00058          

00059     blockquote() ;     

00060          

00061     blockquote() ;     

00062          

00063     p("texte") ;     

00064     echo " Comment dire &agrave; $R qu'on veut changer de r&eacute;pertoire&nbsp;?" ;     

00065     echo " Et connaitre le r&eacute;pertoire en cours&nbsp;?" ;     

00066     echo " Qu'est-ce qu'un script&nbsp;?" ;     

00067     echo " Faut-il programmer pour &eacute;crire un script&nbsp;?" ;     

00068     echo " A quoi servent les fonctions " ;     

00069     echo hrrr("source") ;     

00070     echo " et " ;     

00071     echo hrrr("sink")."&nbsp;?" ;   ;     

00072     echo " Comment charger les ".b("fonctions (gH)")." &nbsp;?" ;     

00073     finp() ;     

00074          

00075     finblockquote() ;     

00076          

00077     solution($numExo,$numSerie) ;     

00078          

00079     p("texte") ;     

00080     echo "Pour changer de r&eacute;pertoire, il faut utiliser la fonction " ;     

00081     echo hrrr("getwd","","setwd()") ;     

00082     echo" et pour connaitre le r&eacute;pertoire en cours, on utilise " ;     

00083     echo hrrr("getwd")."." ;     

00084     finp() ;     

00085          

00086     p("texte") ;     

00087     echo "Un script est juste un ensemble de commandes $R &eacute;crites dans un fichier, comme celles dans les encadr&eacute;s en bleu clair de cette page. " ;     

00088     echo " Il n'y a pas besoin de savoir programmer pour &eacute;crire des scripts &eacute;l&eacute;mentaires. " ;     

00089     echo " Pour &eacute;x&eacute;cuter un script dans une session, on utilise la fonction " ;     

00090     echo hrrr("source")." avec &eacute;ventuellement les param&egrave;tres ".b("echo").",  ".b("verbose").", ".b("print.eval")." etc. " ;     

00091     echo " La fonction " ;     

00092     echo hrrr("sink")." permet de g&eacute;rer la sortie des affichages, voire de la rediriger vers un fichier, pour conserver une trace " ;     

00093     echo  " de ce qui a &eacute;t&eacute; ex&eacute;cut&eacute;. ";     

00094     finp() ;     

00095          

00096     p("texte") ;     

00097     echo "Voici un exemple de script, nomm&eacute; (!) ".href("prog.r")." encod&eacute; en ISO8859-1." ;     

00098     finp() ;     

00099          

00100     entree_R("prog.r") ;     

00101          

00102     p("texte") ;     

00103     echo "Voici ce qui se passe si on essaie de l'ex&eacute;cuter sous Linux (qui utilise par d&eacute;faut un encodage UTF). " ;     

00104     finp() ;     

00105          

00106     sortie_R("script1_sor.txt") ;     

00107          

00108     p("texte") ;     

00109     echo "Il faut donc utiliser le param&egrave;tre ".b("encoding")." ici : " ;     

00110     finp() ;     

00111          

00112     sortie_R("script2_sor.txt") ;     

00113          

00114     p("texte") ;     

00115     echo "C'est d&eacute;j&agrave; mieux, sauf pour la sortie... Par contre, on ne voit pas quelles affectations ont &eacute;t&eacute; ex&eacute;cut&eacute;es. " ;     

00116     echo " Essayons avec le param&egrave;tre ".b("echo")."&nbsp;:" ;     

00117     finp() ;     

00118          

00119     sortie_R("script3_sor.txt") ;     

00120          

00121     p("texte") ;     

00122     echo "Ce n'est pas cela, mais au moins, on voit quelle instruction est ex&eacute;cut&eacute;e. La solution doit sans doute utiliser " ;     

00123     echo " le param&egrave;tre ".b("print.eval")."&nbsp;:" ;     

00124     finp() ;     

00125          

00126     sortie_R("script4_sor.txt") ;     

00127          

00128     p("texte") ;     

00129     echo "Enfin, on peut avoir encore plus de d&eacute;tails avec le param&egrave;tre ".b("verbose")."&nbsp;:" ;     

00130     finp() ;     

00131          

00132     sortie_R("script5_sor.txt") ;     

00133          

00134     p("texte") ;     

00135     echo "Les ".b("fonctions (gH)")." sont un ensemble de fonctions qui calculent puis affichent en fran&ccedil;ais disponibles sur internet, &agrave; l'adresse " ;     

00136     echo href("http://forge.info.univ-angers.fr/~gh/statgh.r","statgh.r").". " ;     

00137     echo " Une page d'explication nomm&eacute;e ".href("http://forge.info.univ-angers.fr/~gh/wstat/statgh.php","statgh.php")." leur est consacr&eacute;e et " ;     

00138     echo " une interface les montre &agrave; l'adresse ".href("http://forge.info.univ-angers.fr/~gh/wstat/statghfns.php","statghfns.php").". " ;     

00139     echo " Nous conseillons d'apprendre &agrave; utiliser " ;     

00140     echo href("http://forge.info.univ-angers.fr/~gh/wstat/statghfns.php?lafns=cats","cats()").", " ;     

00141     echo href("http://forge.info.univ-angers.fr/~gh/wstat/statghfns.php?lafns=catss","catss()")." et surtout  " ;     

00142     echo href("http://forge.info.univ-angers.fr/~gh/wstat/statghfns.php?lafns=sinksrc","sinksrc()")." pour travailler sereinement avec les scripts. " ;     

00143     echo " C'est gr&acirc;ce &agrave; cette derni&egrave;re fonction que nous avons produit toutes les sorties de ces pages Web." ;     

00144          

00145          

00146     finp() ;     

00147          

00148     finsolution() ;     

00149          

00150     finblockquote() ;     

00151          

00152     ## -------------------------------------------------------------------------------------------     

00153          

00154     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Lecture de fichiers textes et Excel et gestion des accents     

00155          

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

00157          

00158     blockquote() ;     

00159          

00160     blockquote() ;     

00161          

00162     p("texte") ;     

00163     echo "Comment lire un fichier-texte de valeurs num&eacute;riques comme ".href("elf.txt")." avec R&nbsp;? " ;     

00164     echo "Et un fichier Excel comme ".href("elf.xls")." ou ".href("elf.xlsx")."&nbsp;? " ;     

00165     echo "Et un fichier Open Office Calc comme ".href("elf.ods")."&nbsp;? " ;     

00166     echo " Et un fichier avec des valeurs caract&egrave;res comme ".href("elf2.txt")."&nbsp;? " ;     

00167     echo " Et un fichier CSV ou un fichier d&eacute;limit&eacute; avec des points-virgules&nbsp;?" ;     

00168     finp() ;     

00169          

00170     p("texte") ;     

00171     echo "R sait-il lire des fichiers avec des accents Windows ? des accents ISO, UTF &nbsp;?" ;     

00172     finp() ;     

00173          

00174     p("texte") ;     

00175     echo " Comment lire du texte \"brut\" ? " ;     

00176     finp() ;     

00177          

00178     p("texte") ;     

00179     echo em("Questions sp&eacute;cialis&eacute;es&nbsp;:") ;     

00180     finp() ;     

00181          

00182     p("texte") ;     

00183     echo "&laquo;Mes donn&eacute;es ont parfois des lignes vides et des commentaires, comme ci-dessous " ;     

00184     echo "(fichier ".href("dataspec.txt").")&nbsp;:" ;     

00185     finp() ;     

00186          

00187     pre_fichier("dataspec.txt","cadre") ;     

00188          

00189     p("texte") ;     

00190     echo " Comment les lire avec $R&nbsp;?&raquo;" ;     

00191     finp() ;     

00192          

00193     p("texte") ;     

00194     echo "&laquo;Moi, j'utilise souvent des donn&eacute;es issues du site web " ;     

00195     #echo href("http://www.dna.affrc.go.jp/PLACE/signalup.html","PLACE","gbleuf nou") ;     

00196     #echo href("http://www.dna.affrc.go.jp/PLACE/","PLACE","gbleuf nou") ;     

00197     echo href("https://www.ncbi.nlm.nih.gov/pubmed/9847208?dopt=Abstract","PLACE","gbleuf nou") ;     

00198     echo " et mes donn&eacute;es ressemblent &agrave; " ;     

00199     finp() ;     

00200          

00201     pre_fichier("demoplace.txt","cadre") ;     

00202          

00203     p("texte") ;     

00204     echo " Comment r&eacute;cup&eacute;rer juste les indications de comptage et de localisation de site&nbsp;?&raquo;" ;     

00205     finp() ;     

00206          

00207     finblockquote() ;     

00208          

00209     solution($numExo,$numSerie) ;     

00210          

00211     p("texte") ;     

00212     echo "Comme nous l'avons vu dans la s&eacute;ance 1, $R dispose avec la fonction " ;     

00213     echo hrrr("read.table","utils","","gvert nou") ;     

00214     echo " de nombreuses options pour lire les fichiers-textes. " ;     

00215     echo "Cette fonction ".hrrr("read.table","utils","","gvert nou") ;     

00216     echo " appartient au package ".hrrp("utils").". " ;     

00217     finp() ;     

00218          

00219     p("texte") ;     

00220     echo "Les fichiers qui contiennent des donn&eacute;es num&eacute;riques pour traitements statistiques ont en g&eacute;n&eacute;ral une structure " ;     

00221     echo " particuli&egrave;re, &agrave; savoir un nombre constant de \"mots-valeur\" par ligne, ce qui permet de parler de colonnes de " ;     

00222     echo" chiffres ou ".em("variables statistiques").". " ;     

00223     echo " Ces valeurs sont souvent d&eacute;limit&eacute;es ou s&eacute;par&eacute;es par un m&ecirc;me symbole, parfois r&eacute;p&eacute;t&eacute;, comme l'espace, " ;     

00224     echo " le caract&egrave;re de tabulation, la virgule ou le point virgule. " ;     

00225     echo " En particulier le format dit " ;     

00226     echo href("http://en.wikipedia.org/wiki/Comma-separated_values","CSV") ;     

00227     echo " est tr&egrave;s pris&eacute; par les statisticien(nes). " ;     

00228     echo " $R sait le traiter avec la fonction " ;     

00229     echo hrrr("read.table","utils","read.csv()","gvert nou") ;     

00230     echo ". Comme les am&eacute;ricains utilisent un point pour les d&eacute;cimales, la virgule peut servir de s&eacute;parateur. " ;     

00231     echo " En France, la virgule sert pour les d&eacute;cimales et on utilise donc plut&ocirc;t le point-virgule comme " ;     

00232     echo " s&eacute;parateur, d'o&ugrave; les fonctions " ;     

00233     echo hrrr("read.table","utils","read.csv()","gvert nou") ;     

00234     echo " et " ;     

00235     echo hrrr("read.table","utils","read.csv2()","gvert nou") ;     

00236     echo ", mais il est possible, bien s&ucirc;r, d'indiquer son propre d&eacute;limiteur." ;     

00237     echo " Cette notion de structure en colonne d&eacute;finit ce que $R nomme des ".b("data frame").". " ;     

00238     echo " Utiliser ".hrrr("read.table","utils","","gvert nou")." renvoie un data frame." ;     

00239     echo " Les data frame ressemblent &agrave; des matrices, avec des lignes et des colonnes, mais ce ne sont pas des matrices " ;     

00240     echo " car ce sont des listes." ;     

00241     finp() ;     

00242          

00243     entree_R("dataframe.r") ;     

00244     sortie_R("dataframe_sor.txt") ;     

00245          

00246          

00247     p("texte") ;     

00248     echo "L'int&eacute;r&ecirc;t du format " ;     

00249     echo href("http://fr.wikipedia.org/wiki/Comma-separated_values","CSV") ;     

00250     echo " est d'&ecirc;tre un format-texte et qu'on peut donc voir les donn&eacute;es avec un simple " ;     

00251     echo " navigateur ou m&ecirc;me un &eacute;diteur de texte (par exemple pour effectuer des " ;     

00252     echo s_span("Edition/Remplacer&nbsp;tout","gvert")." si besoin est). Les logiciels Excel et " ;     

00253     echo " Open Office Write savent bien exporter dans ces formats." ;     

00254     finp() ;     

00255          

00256          

00257     p("texte") ;     

00258     echo "Pour lire le fichier ".href("elf.txt").", un  simple appel de " ;     

00259     echo hrrr("read.table","utils","","gvert nou") ;     

00260     echo " suffit. Il n'y a pas d'indication de nom de colonne en ligne 1, " ;     

00261     echo " donc le param&egrave;tre ".b("head")." doit &ecirc;tre mis &agrave; faux (FALSE en anglais). Le mot 1 de chaque ligne semble &ecirc;tre un identifiant. " ;     

00262     echo " Si tel est le cas, il faut utiliser ".b("row.names=1")."&nbsp; sinon, pas besoin de pr&eacute;ciser ".b("row.names").". " ;     

00263     echo " La fonction ".hrrr("colnames","base","colnames()") ;     

00264     echo " permet de d&eacute;finir ou de r&eacute;finir tout ou partie des noms de colonnes. " ;     

00265     finp() ;     

00266          

00267     entree_R("litelf1.r") ;     

00268     sortie_R("litelf1_sor.txt") ;     

00269          

00270     p("texte") ;     

00271     echo "Pour lire le fichier Excel ".b(".xls")." correspondant, il faut avoir install&eacute; le " ;     

00272     echo " package ".hrrp("gdata").". " ;     

00273     echo " On dispose alors de la fonctions " ;     

00274     echo hrrr("read.xls","gdata","","gvert nou") ;     

00275     echo " alors que pour lire la version ".b(".xlsx")." du fichier, il faut avoir install&eacute; le " ;     

00276     echo " package ".hrrp("xlsx")." qui fournit la  fonction " ;     

00277     echo hrrr("read.xlsx","xlsx","","gvert nou") ;     

00278     echo " dont le param&egrave;tre ".b("sheetIndex")." est requis, sans valeur par d&eacute;faut." ;     

00279     echo " On peut aussi utiliser le package " ;     

00280     echo hrrp("XLConnect").", mais on ne peut lire que des fichiers locaux. " ;     

00281     echo hrrp("XLConnect")." &eacute;crit aussi des fichiers Excel. La lecture de " ;     

00282     echo href("http://cran.r-project.org/web/packages/XLConnect/XLConnect.pdf","XLConnect.pdf")." est conseill&eacute;e." ;     

00283     finp() ;     

00284          

00285     entree_R("litelf2.r") ;     

00286     sortie_R("litelf2_sor.txt") ;     

00287          

00288     p("texte") ;     

00289     echo "Il n'est pas forc&eacute;ment ais&eacute; de lire des fichiers ".b(".ods")." car la fonction " ;     

00290     echo hrrr("read.gnumeric.sheet","gnumeric","","gvert nou") ;     

00291     echo " du package ".hrrp("gnumeric")." requiert que le logiciel " ;     

00292     echo href("https://projects.gnome.org/gnumeric/","gnumeric") ;     

00293     echo " soit aussi install&eacute;, &agrave; cause de sa commande ".b("ssconvert").". " ;     

00294     echo " Nous conseillons plut&ocirc;t d'enregistrer le fichier ".b(".ods")." en ".b(".xls") ;     

00295     echo " et de lire comme ci-dessus. Il n'est pas conseill&eacute; d'enregistrer en ".b(".xlsx") ;     

00296     echo " parce que cela produit des fichiers plus gros, plus complexes " ;     

00297     echo " (les fichiers .xlsx sont en fait des archives qui contiennent des fichiers XML), " ;     

00298     echo " ce qui rend la lecture plus lente." ;     

00299     finp() ;     

00300          

00301     p("texte") ;     

00302     echo "Lorsqu'on lit des donn&eacute;es caract&egrave;res, $R en fait automatiquement par d&eacute;faut des facteurs, c'est-&agrave;-dire des " ;     

00303     echo " variables qualitatives dont les modalit&eacute;s sont les divers mots rencontr&eacute;s. Pour modifier ce comportement, " ;     

00304     echo " il faut utiliser le param&egrave;tre ".b("as.is")." de " ;     

00305     echo hrrr("read.table","utils","","gvert nou").". " ;     

00306     finp() ;     

00307          

00308     entree_R("litelf3.r") ;     

00309     sortie_R("litelf3_sor.txt") ;     

00310          

00311          

00312     p("texte") ;     

00313     echo "La prise en compte des accents se fait avec le param&egrave;tre ".b("encoding='latin1'")."." ; # ."&nbsp;:" ;     

00314     echo " On peut aussi utiliser " ;     

00315     echo hrrr("Encoding") ;     

00316     echo " et " ;     

00317     echo hrrr("iconv")."." ;     

00318     finp() ;     

00319          

00320     sortie_R("litelf4_sor.txt") ;     

00321          

00322     p("texte") ;     

00323     echo "Pour lire un fichier-texte \"litt&eacute;raire\" comme ".href("cigale.txt").", on utilise " ;     

00324     echo hrrr("readLines").", sachant qu'en mode interactif, " ;     

00325     echo hrrr("readline")." (sans \"s\" et avec un \"l\" minuscule) assure la lecture au clavier." ;     

00326     finp() ;     

00327          

00328     sortie_R("fable_sor.txt") ;     

00329          

00330     p("texte") ;     

00331     echo em("R&eacute;ponses aux questions sp&eacute;cialis&eacute;es&nbsp;:") ;     

00332     finp() ;     

00333          

00334     p("texte") ;     

00335     echo "Les lignes vides et les commentaires ne sont pas un probl&egrave;me car $R a des options pour cela. " ;     

00336     echo " Voici les instructions $R correspondantes &agrave; la lecture de ".href("videcmt.txt").".  Tout le travail est fait par " ;     

00337     echo hrrr("read.table","utils","","gvert nou")."."  ;     

00338     finp() ;     

00339          

00340     entree_R("videcmt.r") ;     

00341          

00342     p("texte") ;     

00343     echo " Et le r&eacute;sultat de leur ex&eacute;cution&nbsp;:" ;     

00344     finp() ;     

00345          

00346     sortie_R("videcmt.res") ;     

00347          

00348     p("texte") ;     

00349     echo "Par contre la lecture des fichiers pour le logiciel " ;     

00350     #echo href("http://www.dna.affrc.go.jp/PLACE/signalup.html","PLACE","gbleuf nou") ;     

00351     echo b("PLACE") ;     

00352     echo " ne peut pas se faire de fa&ccedil;on simple. Il faut &eacute;crire un programme " ;     

00353     echo " pour parcourir les lignes, ignorer ce qu'on lit tant qu'on n'a pas vu la premi&egrave;re ligne de tirets, puis " ;     

00354     echo " d&eacute;couper les lignes et s'arr&ecirc;ter lorsque qu'on rencontre la seconde ligne de tirets. Il faut donc " ;     

00355     echo " apprendre &agrave; programmer en $R pour y arriver, ce qui est le sujet d'une autre session de cours... " ;     

00356     finp() ;     

00357          

00358     finsolution() ;     

00359          

00360     finblockquote() ;     

00361          

00362     ## -------------------------------------------------------------------------------------------     

00363          

00364     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Listes en $R     

00365          

00366     ## -------------------------------------------------------------------------------------------     

00367          

00368     blockquote() ;     

00369          

00370     blockquote() ;     

00371          

00372     p("texte") ;     

00373     echo "Quelle est la diff&eacute;rence entre une liste et un vecteur&nbsp;?" ;     

00374     echo " Comment utilise-t-on les listes en $R &nbsp;?" ;     

00375     finp() ;     

00376          

00377     finblockquote() ;     

00378          

00379     solution($numExo,$numSerie) ;     

00380          

00381     p("texte") ;     

00382     echo "Une liste se cr&eacute;e avec ".hrrr("list").". " ;     

00383     echo " Comme un vecteur, c'est un conteneur, mais les divers &eacute;l&eacute;ments peuvent &ecirc;tre de nature diff&eacute;rente. " ;     

00384     echo " Il est d'usage de parler des &eacute;l&eacute;ments d'un vecteur et des composant[e]s d'une liste. El&eacute;ments et composants " ;     

00385     echo " peuvent &ecirc;tre nomm&eacute;s, mais l'usage veut qu'on nomme surtout les composants. On acc&egrave;de aux composants " ;     

00386     echo " par leur nom et/ou leur position. On peut appliquer une fonction &agrave; tous les composants d'une liste avec " ;     

00387     echo hrrr("lapply").", qui renvoie une liste, et avec " ;     

00388     echo hrrr("lapply","base","sapply").", qui renvoie un vecteur. " ;     

00389     echo " Le nombre de composants s'obtient avec la fonction ".hrrr("length").". " ;     

00390     finp() ;     

00391          

00392     entree_R("liste.r") ;     

00393     sortie_R("liste_sor.txt") ;     

00394          

00395     # d&eacute;tailler ifelse() et cut()     

00396          

00397     finsolution() ;     

00398          

00399     finblockquote() ;     

00400          

00401     ## -------------------------------------------------------------------------------------------     

00402          

00403     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Variables qualitatives et quantitatives     

00404          

00405     ## -------------------------------------------------------------------------------------------     

00406          

00407     blockquote() ;     

00408          

00409     blockquote() ;     

00410          

00411     p("texte") ;     

00412     echo "Comment $R g&egrave;re-t-il les variables qualitatives et quantitatives&nbsp;?" ;     

00413     echo " Qu'obtient-on quand on lit des donn&eacute;es dans un fichier, du quantitatif ou du qualitatif&nbsp;?" ;     

00414     finp() ;     

00415          

00416     finblockquote() ;     

00417          

00418     solution($numExo,$numSerie) ;     

00419          

00420     p("texte") ;     

00421     echo "R n'a qu'une seule r&egrave;gle&nbsp;: tout ce qui est num&eacute;rique est quantitatif. Et donc, comme corollaire, tout ce qui est caract&egrave;re est qualitatif. " ;     

00422     echo " Pour convertir de quantitatif &agrave; qualitatif, il faut passer par la fonction " ;     

00423     echo hrrr("factor")." et indiquer les labels des modalit&eacute;s. Dans le vocabulaire R, les variables qualitatives sont d&eacute;nomm&eacute;es ".em("facteurs").". " ;     

00424     echo "Par contre, pour convertir dans l'autre sens, si l'on connait des bornes de d&eacute;coupage, on peut utiliser " ;     

00425     echo hrrr("ifelse")." et " ;     

00426     echo hrrr("cut").". " ;     

00427     finp() ;     

00428          

00429     entree_R("facteurs.r") ;     

00430     sortie_R("facteurs_sor.txt") ;     

00431          

00432     # d&eacute;tailler ifelse() et cut()     

00433          

00434          

00435     p("texte") ;     

00436     echo b("Remarque : ") ;     

00437     echo " si on veut garder toutes les colonnes caract&egrave;res sous forme de chaines de caract&egrave;res, il faut pr&eacute;ciser ".b("as.is=TRUE")." dans la lecture des fichiers " ;     

00438     echo " ou utiliser ".b("stringsAsFactors=FALSE").". " ;     

00439     finp() ;     

00440     finsolution() ;     

00441          

00442     finblockquote() ;     

00443          

00444     ## -------------------------------------------------------------------------------------------     

00445          

00446     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # R&eacute;cup&eacute;ration de tableaux HTML     

00447          

00448     ## -------------------------------------------------------------------------------------------     

00449          

00450     blockquote() ;     

00451          

00452     blockquote() ;     

00453          

00454     p("texte") ;     

00455     echo "Si on lit la page du wiki anglais sur les acides amin&eacute;s, soit " ;     

00456     echo href("http://en.wikipedia.org/wiki/Amino_acid","[...]wiki/Amino_acid") ;     

00457     echo " les tableaux 2 (classification) et 4 (propri&eacute;t&eacute;s) semblent tr&egrave;s int&eacute;ressants. Comment r&eacute;cup&eacute;rer leur contenu dans un data frame&nbsp;?" ;     

00458     finp() ;     

00459          

00460     p("texte") ;     

00461     echo "Reprendre avec le tableau 4 (propri&eacute;t&eacute;s) de la " ;     

00462     echo href("http://fr.wikipedia.org/wiki/Acide_amin%C3%A9","page correspondante","nou gbleuf") ;     

00463     echo " du wiki fran&ccedil;ais. " ;     

00464     finp() ;     

00465          

00466     finblockquote() ;     

00467          

00468     solution($numExo,$numSerie) ;     

00469          

00470     p("texte") ;     

00471     echo "Avec la fonction " ;     

00472     echo hrrr("readHTMLTable","XML") ;     

00473     echo " du package ";     

00474     echo hrrp("XML").", rien de plus simple, la preuve&nbsp;:" ;     

00475     finp() ;     

00476          

00477     entree_R("readwikiaa.r") ;     

00478          

00479     p("texte") ;     

00480     echo "R&eacute;sultats d'ex&eacute;cution&nbsp;:" ;     

00481     finp() ;     

00482          

00483     div("pluspetit") ;     

00484     sortie_R("readwikiaa_sor.txt") ;     

00485     findiv() ;     

00486          

00487     p("texte") ;     

00488     echo "Mais bien s&ucirc;r un peu de \"m&eacute;nage\" ne fait pas de mal&nbsp;:" ;     

00489     finp() ;     

00490          

00491     entree_R("readwikiaa2.r") ;     

00492          

00493     p("texte") ;     

00494     echo "R&eacute;sultats d'ex&eacute;cution&nbsp;:" ;     

00495     finp() ;     

00496          

00497     sortie_R("readwikiaa2_sor.txt") ;     

00498          

00499     finsolution() ;     

00500          

00501     finblockquote() ;     

00502          

00503     ## -------------------------------------------------------------------------------------------     

00504          

00505     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Regroupement et fusion de donn&eacute;es     

00506          

00507     ## -------------------------------------------------------------------------------------------     

00508          

00509     blockquote() ;     

00510          

00511     blockquote() ;     

00512          

00513     p("texte") ;     

00514     echo "On veut fusionner horizontalement (dans le sens des lignes) les fichiers ".href("datah1.txt")." et ".href("datah2.txt").". " ;     

00515     echo " Quel code $R faut-il &eacute;crire&nbsp;? " ;     

00516     echo " Et si on veut fusionner verticalement (dans le sens des colonnes) les fichiers ".href("datav1.txt")." et ".href("datav2.txt")."&nbsp;? " ;     

00517     finp() ;     

00518          

00519     p("texte") ;     

00520     echo "Plus g&eacute;n&eacute;ralement, comment fusionner des donn&eacute;es selon une colonne commune, " ;     

00521     echo " par exemple pour ".href("partie1.txt")." et ".href("partie2.txt")." &nbsp;?" ;     

00522     finp() ;     

00523          

00524     finblockquote() ;     

00525          

00526     solution($numExo,$numSerie) ;     

00527          

00528     p("texte") ;     

00529     echo "La fusion horizontale de donn&eacute;es de m&ecirc;me structure est r&eacute;alis&eacute;e par " ;     

00530     echo hrrr("cbind","","rbind()") ;     

00531     echo " alors que la fusion verticale de donn&eacute;es avec les m&ecirc;mes identifiants de ligne est r&eacute;alis&eacute;e par " ;     

00532     echo hrrr("cbind").". " ;     

00533     echo " On notera que ".b("cbind()")." produit une matrice, ce qui force souvent l'affichage en colonne, ce qui est bien pratique  " ;     

00534     echo " et que la fonction ".hrrr("names")." se comporte dans certains cas comme ".hrrr("colnames").". " ;     

00535     finp() ;     

00536          

00537     entree_R("bind.r") ;     

00538     sortie_R("bind_sor.txt") ;     

00539          

00540          

00541     p("texte") ;     

00542     echo "En cas d'erreur sur les structures, $R affiche des messages pas toujours compr&eacute;hensibles&nbsp;:" ;     

00543     finp() ;     

00544          

00545     entree_R("bind_err.txt") ;     

00546          

00547     p("texte") ;     

00548     echo "La fusion g&eacute;n&eacute;rale se fait sur cl&eacute; d'appariement via " ;     

00549     echo hrrr("merge").". " ;     

00550     echo " Il y a bien s&ucirc;r des options pour pr&eacute;ciser cette cl&eacute;, ce qu'il faut faire des donn&eacute;es orphelines " ;     

00551     echo " &agrave; droite et &agrave; gauche... " ;     

00552     finp() ;     

00553          

00554     sortie_R("lesmerge_sor.txt") ;     

00555          

00556     finsolution() ;     

00557          

00558     finblockquote() ;     

00559          

00560     ## -------------------------------------------------------------------------------------------     

00561          

00562     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Indi&ccedil;age, filtrage et s&eacute;lection de donn&eacute;es"     

00563          

00564     ## -------------------------------------------------------------------------------------------     

00565          

00566     blockquote() ;     

00567          

00568     blockquote() ;     

00569          

00570     p("texte") ;     

00571     echo "Comment obtenir la valeur du n-i&egrave;me &eacute;l&eacute;ment d'une structure ? le maximum ? que les valeurs positives ? " ;     

00572     finp() ;     

00573          

00574          

00575     finblockquote() ;     

00576          

00577     solution($numExo,$numSerie) ;     

00578          

00579     p("texte") ;     

00580     echo "L'indexation avec les crochets droits [ et ] permet de d&eacute;signer le n-i&egrave;me &eacute;l&eacute;ment d'une structure. " ;     

00581     echo " Un seul indice suffit pour les vecteurs alors qu'il en faut deux pour les matrices, s&eacute;par&eacute;s par une virgule. " ;     

00582     echo " Pour les listes, on peut utiliser les crochets simples ou doubles. Dans le premier cas, la structure de liste est " ;     

00583     echo " conserv&eacute;e. " ;     

00584     finp() ;     

00585          

00586     entree_R("indexation.r") ;     

00587     sortie_R("indexation_sor.txt") ;     

00588          

00589     p("texte") ;     

00590     echo "Pour trouver le maximum d'une structure, on utilise en g&eacute;n&eacute;ral la fonction " ;     

00591     echo hrrr("Extremes","","max()") ;     

00592     echo ", mais qu'on applique diff&eacute;remment suivant les structures. " ;     

00593     echo " Pour un vecteur et une matrice, ".b("max()")." renvoie le maximum de tous les &eacute;l&eacute;ments rencontr&eacute;s. " ;     

00594     echo " Si on veut les maxima en ligne ou en colonne, il faut utiliser ".b("apply(max...")." en indiquant la " ;     

00595     echo " marge (MARGIN)&nbsp;: 1 pour les lignes et 2 pour les colonnes. Pour une liste qui contient seulement des " ;     

00596     echo " vecteurs ou des matrices, ".b("lapply(max...")." et ".b("sapply(max...")." sont des solutions acceptables. " ;     

00597     echo " S'il y a des listes dans la liste, il faut forcer un appel r&eacute;cursif avec ".b("rapply(max...").". " ;     

00598     finp() ;     

00599          

00600     p("texte") ;     

00601     echo " La position du maximum s'obtient avec "  ;     

00602     echo hrrr("which.min","","which.max()") ;     

00603     echo " mais ne renvoie qu'une seule position. Un test direct avec ".b("==max(...")." permet de trouver toutes les " ;     

00604     echo " positions du maximum, si on applique son r&eacute;sultat aux indices de la structure." ; # &agrave; laquelle on l'applique. " ;     

00605     echo " Tout test logique sur une structure permet de filtrer une structure. Voir ci-dessous. " ;     

00606     echo " Au passage, on notera que " ;     

00607     echo hrrr("which.min","","which.max()")." est une forme particuli&egrave;re de " ;     

00608     echo hrrr("which")."." ;     

00609     finp() ;     

00610          

00611     entree_R("lesmax.r") ;     

00612     sortie_R("lesmax_sor.txt") ;     

00613          

00614     finsolution() ;     

00615          

00616     finblockquote() ;     

00617          

00618     ## -------------------------------------------------------------------------------------------     

00619          

00620     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Conversion de structures de donn&eacute;es en $R     

00621          

00622     ## -------------------------------------------------------------------------------------------     

00623          

00624     blockquote() ;     

00625          

00626     blockquote() ;     

00627     p("texte") ;     

00628     echo " Quelles sont les diff&eacute;rentes structures de donn&eacute;es en $R et comment passe-t-on des unes aux autres&nbsp;?" ;     

00629     finp() ;     

00630     finblockquote() ;     

00631          

00632     solution($numExo,$numSerie) ;     

00633          

00634     p("texte") ;     

00635     echo "Les principales structures de donn&eacute;es &eacute;l&eacute;mentaires sont les listes, les vecteurs, les matrices et les \"data frames\", construites directement par " ;     

00636     echo hrrr("list").", " ;     

00637     echo hrrr("vector").", " ;     

00638     echo hrrr("matrix")." et " ;     

00639     echo hrrr("data.frame")." ou indirectement par des fonctions comme " ;     

00640     echo hrrr("seq").", " ;     

00641     echo hrrr("rep").", " ;     

00642     echo hrrr("range").", " ;     

00643     echo hrrr("which")."... " ;     

00644     finp() ;     

00645          

00646     p("texte") ;     

00647     echo "Les passerelles sont construites avec ".b("\"as\".")." comme "  ;     

00648     echo hrrr("vector","","as.vector()").", " ;     

00649     echo hrrr("matrix","","as.matrix()").", " ;     

00650     echo hrrr("list","","as.list()").", " ;     

00651     echo hrrr("as.data.frame")."... " ;     

00652     echo " mais aussi avec " ;     

00653     echo hrrr("unlist").". " ;     

00654     finp() ;     

00655          

00656     p("texte") ;     

00657     echo "On connait souvent le type d'une variable &agrave; l'aide de la fonction " ;     

00658     echo hrrr("class").", m&ecirc;me si certains objets peuvent h&eacute;riter de plusieurs classes. " ;     

00659     finp() ;     

00660          

00661     entree_R("classes.r") ;     

00662     sortie_R("classes.sor") ;     

00663          

00664     p("text") ;     

00665     echo "De fa&ccedil;on plus fine, les data frames sont des listes. Les matrices peuvent avoir des " ;     

00666     echo hrrr("colnames","","rownames") ;     

00667     echo " et des " ;     

00668     echo hrrr("colnames"). " (sans point) " ;     

00669     echo " alors que les listes peuvent avoir des " ;     

00670     echo hrrr("names"). " et que les data frames peuvent avoir des " ;     

00671     echo hrrr("row.names")." (avec un point), des " ;     

00672     echo hrrr("names"). ". " ;     

00673     finp() ;     

00674          

00675     entree_R("names.r") ;     

00676     sortie_R("names_sor.txt") ;     

00677          

00678     p("texte") ;     

00679     echo b("Rappel : ") ;     

00680     echo "il y a coercion de type pour les vecteurs et les matrices, c'est-&agrave;-dire que $R contraint les &eacute;l&eacute;ments &agrave; &ecirc;tre de " ;     

00681     echo " m&ecirc;me type. " ;     

00682     finp() ;     

00683          

00684     entree_R("coercion.r") ;     

00685     sortie_R("coercion.sor") ;     

00686          

00687     finsolution() ;     

00688          

00689     finblockquote() ;     

00690          

00691     ## -------------------------------------------------------------------------------------------     

00692          

00693     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; #  Gestion des donn&eacute;es manquantes     

00694          

00695     ## -------------------------------------------------------------------------------------------     

00696          

00697     blockquote() ;     

00698          

00699     blockquote() ;     

00700     p("texte") ;     

00701     echo "Il arrive quand on importe des donn&eacute;es, qu'il ait des \"trous\", ce qui aboutit &agrave; des donn&eacute;es manquantes." ;     

00702     echo " Comment fait-on pour les g&eacute;rer en R&nbsp;?" ;     

00703     finp() ;     

00704          

00705     p("texte") ;     

00706     echo " Y a-t-il un impact sur les calculs&nbsp;?" ;     

00707     finp() ;     

00708          

00709     finblockquote() ;     

00710          

00711     solution($numExo,$numSerie) ;     

00712          

00713          

00714     p("texte") ;     

00715     echo "Oui, malheureusement les valeurs " ;     

00716     echo hrrr("NA","","NA")." (".em("not available")." en anglais) ont un fort impact sur les calculs. " ;     

00717     echo " Les NA emp&ecirc;chent de calculer les sommes, donc les moyennes, les variances... " ;     

00718     echo " De plus un test logique avec NA renvoie NA, ce n'est pas tr&egrave;s pratique&nbsp;!" ;     

00719     echo " Pour les chaines de caract&egrave;res, les donn&eacute;es manquantes sont not&eacute;es ".em("&lt;NA&gt;").". " ;     

00720     finp() ;     

00721          

00722     entree_R("nadata.r") ;     

00723     sortie_R("nadata_sor.txt") ;     

00724          

00725     p("texte") ;     

00726     echo "Face &agrave; plusieurs NA dans une matrice ou un data frame, il y a plusieurs strat&eacute;gies. " ;     

00727     sdl() ;     

00728     echo " Soit on supprime toutes les lignes avec des NA &agrave; l'aide de " ;     

00729     echo hrrr("na.fail","stats","na.omit()") ;     

00730     echo " et on peut alors utiliser toutes les fonctions directement, y compris " ;     

00731     echo hrrr("colSums")." et  " ;     

00732     echo hrrr("colSums","base","colMeans()").", soit on utilise les fonctions avec le param&egrave;tre " ;     

00733     echo b("na.rm=TRUE").". " ;     

00734     sdl() ;     

00735     echo "La premi&egrave;re strat&eacute;gie &eacute;limine parfois trop de donn&eacute;es. Voir un exemple d&eacute;taill&eacute; avec la " ;     

00736     echo href("../Eda/edacrs.php?n=6&amp;m=e","question 1","grouge")." de notre cours " ;     

00737     echo href("../Eda/eda.php","EDA","gbleuf")." et sa " ;     

00738     echo href("../Eda/edacrs.php?n=6&amp;m=s","solution","gvert")." d&eacute;taill&eacute;e avec la discussion sur les NA. " ;     

00739     finp() ;     

00740          

00741     # sortie_R("namatdata_sor.txt") ;     

00742          

00743     finsolution() ;     

00744          

00745     finblockquote() ;     

00746          

00747     ## -------------------------------------------------------------------------------------------     

00748          

00749     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Export de donn&eacute;es     

00750          

00751     ## -------------------------------------------------------------------------------------------     

00752          

00753     blockquote() ;     

00754          

00755     blockquote() ;     

00756     p("texte") ;     

00757     echo "Comment faire pour exporter un ".em("data frame")." dans un fichier-texte &nbsp;?" ;     

00758     echo " Et dans un fichier Excel (Open Office Calc)&nbsp;?" ;     

00759     echo " Et au format LaTeX&nbsp;?" ;     

00760     finp() ;     

00761          

00762     p("texte") ;     

00763     echo " Et dans une page Web&nbsp;?" ;     

00764     echo " Et au format Word (Open Office Write)&nbsp;?" ;     

00765     finp() ;     

00766          

00767     p("texte") ;     

00768     echo " Et si ce n'est pas un ".em("data frame")." mais juste une liste de calculs, ou un vecteur&nbsp;? " ;     

00769     finp() ;     

00770     finblockquote() ;     

00771          

00772     solution($numExo,$numSerie) ;     

00773          

00774     p("texte") ;     

00775     echo "De la m&ecirc;me fa&ccedil;on qu'on utilise " ;     

00776     echo hrrr("read.table","utils")." et consor, soit " ;     

00777     echo hrrr("read.table","utils","read.csv()")." et " ;     

00778     echo hrrr("read.table","utils","read.csv2()") ;     

00779     echo " en entr&eacute;e, on dispose de " ;     

00780     echo hrrr("write.table","utils")." en sortie, avec ses avatars " ;     

00781     echo hrrr("write.table","utils","write.csv()")." et " ;     

00782     echo hrrr("write.table","utils","write.csv2()").". " ;     

00783     finp() ;     

00784          

00785     p("texte") ;     

00786     echo "L'utilisation du package " ;     

00787     echo hrrp("R2HTML")." est d'une grande simplicit&eacute; pour g&eacute;n&eacute;rer du code HTML " ;     

00788     echo "(le fichier produit est ".href("dynamic_main.html","ici")."&nbsp;:" ;     

00789     finp() ;     

00790          

00791     entree_R("r2html.r") ;     

00792          

00793     p("texte") ;     

00794     echo "De plus ce package " ;     

00795     echo hrrp("R2HTML")." contient peu de fonctions&nbsp;:" ;     

00796     finp() ;     

00797          

00798     pre_fichier("lls_r2html.sor","cadre") ;     

00799          

00800     p("texte") ;     

00801     echo "Il faut juste regretter que le code produit ne soit pas XHTML valide, que ce soit pour la " ;     

00802     echo " grammaire ".em("Strict")." ou ".em("Trans").", mais cela fournit d&eacute;j&agrave; une base s&eacute;rieuse de code HTML." ;     

00803     echo " Dans la mesure o&ugrave; ".b("Microsoft Word")." et ".b("Open Office Write")." savent lire les fichiers HTML pour en faire des documents de traitement de texte, " ;     

00804     echo " produire du HTML est suffisant pour produire du Word, dans un premier temps." ;     

00805     finp() ;     

00806          

00807     p("texte") ;     

00808     echo "Un autre package qui permet de cr&eacute;er du HTML est " ;     

00809     echo hrrp("hwriter")." et ses fonctions " ;     

00810     echo hrrr("openPage","hwriter").",  " ;     

00811     echo hrrr("hwrite","hwriter")." et " ;     

00812     echo hrrr("openPage","hwriter","closePage").". Le code est produit est XHTML valide pour la grammaire ".em("Trans")."&nbsp;:" ;     

00813     finp() ;     

00814          

00815     entree_R("hwr.r") ;     

00816          

00817     p("texte") ;     

00818     echo "Le fichier produit est ".href("demoHwriter.html").". " ;     

00819     echo " On peut s'affranchir du texte de cr&eacute;ation en base de page avec le param&egrave;tre ".b("splash")." dans " ;     

00820     echo hrrr("openPage","hwriter","closePage").". " ;     

00821     echo "Pour aller encore plus loin avec les exports, le package " ;     

00822     echo hrrp("hwriterPlus")." est une extension int&eacute;ressante de " ;     

00823     echo hrrp("hwriter").". " ;     

00824     finp() ;     

00825          

00826     p("texte") ;     

00827     echo "Pour produire du code LaTeX, on peut utiliser le package " ;     

00828     echo hrrp("xtable")." et sa fonction " ;     

00829     echo hrrr("xtable","xtable")." " ;     

00830     echo " ou le package " ;     

00831     echo hrrp("Hmisc")." et sa fonction " ;     

00832     echo hrrr("latex","Hmisc")." qui a l'avantage de cr&eacute;er un fichier de m&ecirc;me nom que la structure, soit ici " ;     

00833     echo href("trees.tex")." (copie locale en .txt " ;     

00834     echo href("trees.tex.txt","ici")."). " ;     

00835     finp() ;     

00836          

00837     entree_R("latex.r") ;     

00838     sortie_R("latex_sor.txt") ;     

00839          

00840     finsolution() ;     

00841          

00842     finblockquote() ;     

00843          

00844     ## -------------------------------------------------------------------------------------------     

00845          

00846     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # $R et SQL     

00847          

00848     ## -------------------------------------------------------------------------------------------     

00849          

00850     blockquote() ;     

00851          

00852     p("texte") ;     

00853     echo "Peut-on et faut-il interfacer $R et SQL&nbsp;?" ;     

00854     finp() ;     

00855          

00856     solution($numExo,$numSerie) ;     

00857          

00858     p("texte") ;     

00859     echo "Oui et non. Oui, car on peut interfacer $R et SQL, mais non parce qu'&agrave; notre avis au moins dans un premier temps il vaut " ;     

00860     echo "mieux s&eacute;parer les activit&eacute;s. D'autant que la connectivit&eacute; via ".hrrp("RODBC")." ou ".hrrp("DBI").", par exemple, demande des installations techniques... " ;     

00861     echo " Dans la mesure o&ugrave; $R sait bien lire les fichiers-texte, le mieux est d'exporter les donn&eacute;es SQL qui sont presque toujours, " ;     

00862     echo " obtenues par la commande ".href("../../tuteurs/tutmysql.htm","SELECT","grouge")." donc qui correspond &agrave; un \"beau\" tableau rectangulaire lisible " ;     

00863     echo " par ".hrrr("read.table","utils")." du package ".hrrp("utils").". " ;     

00864     finp() ;     

00865          

00866     finsolution() ;     

00867          

00868     finblockquote() ;     

00869          

00870     ## -------------------------------------------------------------------------------------------     

00871          

00872     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Pr&eacute;sentation des packages base, gdata, foreign, tools et utils     

00873          

00874     ## -------------------------------------------------------------------------------------------     

00875          

00876     blockquote() ;     

00877          

00878     p("texte") ;     

00879     echo "Que contiennent les packages  base, gdata, tools et utils&nbsp;?" ;     

00880     finp() ;     

00881          

00882     p("texte") ;     

00883     echo "Quelles en sont les fonctions les plus importantes&nbsp;?" ;     

00884     echo " Quels jeux de donn&eacute;es sont fournis par ces packages&nbsp;?" ;     

00885     finp() ;     

00886          

00887     solution($numExo,$numSerie) ;     

00888          

00889     p("texte") ;     

00890     echo "La fonction " ;     

00891     echo hrrr("ls")." liste les objets de l'environnement courant, mais elle peut aussi indiquer les objets dans un  " ;     

00892     echo " package, lorsqu'il est charg&eacute;. Le r&eacute;sultat pour le package " ;     

00893     echo hrrp("base")." est sans appel&nbsp;:" ;     

00894     echo " avec 1167 objets dont 1162 fonctions, il est illusoire de penser connaitre ce package en quelques minutes. " ;     

00895     echo " Les autres packages cit&eacute;s sont relativement moins importants. " ;     

00896     finp() ;     

00897          

00898     entree_R("lsp.r") ;     

00899     sortie_R("lsp.sor") ;     

00900          

00901     p("texte") ;     

00902     echo "On trouvera dans le tableau suivant des liens " ;     

00903     echo "vers la liste des objets de ces packages." ;     

00904     finp() ;     

00905          

00906     blockquote() ;     

00907     table(1,15,"collapse") ;     

00908     entetesTableau("Package Nb_objets Lien","bleu_pastel") ;     

00909     $ldp = preg_split("/\s+/","base gdata tools utils") ;     

00910     $nbo = preg_split("/\s+/","1167 64 97 198") ;     

00911     $ido = -1 ;     

00912     foreach ($ldp as $pkg) {     

00913       $ido++ ;     

00914       tr() ;     

00915         td("","tagris") ; echo $pkg ; fintd() ;     

00916         td("R","tajaunec") ; echo $nbo[$ido]."&nbsp;" ; fintd() ;     

00917         $fic = "lls_".$pkg.".sor" ;     

00918         td("","tarose") ; echo href($fic,"","grouge nou") ; fintd() ;     

00919       fintr() ;     

00920     } # fin pour ;     

00921     fintable() ;     

00922     finblockquote() ;     

00923          

00924     p("texte") ;     

00925     echo "Dans le package " ;     

00926     echo hrrp("utils").", les principales fonctions &agrave; connaitre sont certainement les suivantes, regroup&eacute;es par th&egrave;me&nbsp;:" ;     

00927     finp() ;     

00928          

00929     blockquote() ;     

00930     table(1,15,"collapse") ;     

00931     entetesTableau("Th&egrave;me Fonctions","bleu_pastel") ;     

00932     $ldt = preg_split("/\s+/","aide packages web affichage fichiers") ;     

00933     foreach ($ldt as $them) {     

00934       $ido++ ;     

00935       tr() ;     

00936         td("","tagris") ; echo $them ; fintd() ;     

00937         td("","tajaunec") ;     

00938         if ($them=="aide") {     

00939            echo "&nbsp;".hrrr("apropos","utils")." " ;     

00940            echo "&nbsp;".hrrr("browseVignettes","utils")." " ;     

00941            echo "&nbsp;".hrrr("help","utils")." " ;     

00942            echo "&nbsp;".hrrr("help.search","utils")." " ;     

00943            echo "&nbsp;".hrrr("help.start","utils")." " ;     

00944            echo "&nbsp;".hrrr("RSiteSearch","utils")." " ;     

00945            echo "&nbsp;".hrrr("vignette","utils")." " ;     

00946         } # fin si     

00947         if ($them=="packages") {     

00948            echo "&nbsp;".hrrr("install.packages","utils")." " ;     

00949            echo "&nbsp;".hrrr("installed.packages","utils")." " ;     

00950            echo "&nbsp;".hrrr("update.packages","utils")." " ;     

00951         } # fin si     

00952         if ($them=="web") {     

00953            echo "&nbsp;".hrrr("browseURL","utils")." " ;     

00954            echo "&nbsp;".hrrr("URLencode","utils")." " ;     

00955            echo "&nbsp;".hrrr("URLencode","utils","URLdecode()")." " ;     

00956            echo "&nbsp;".hrrr("url.show","utils")." " ;     

00957         } # fin si     

00958         if ($them=="affichage") {     

00959            echo "&nbsp;".hrrr("head","utils")." " ;     

00960            echo "&nbsp;".hrrr("ls_str","utils","ls.str()")." " ;     

00961            echo "&nbsp;".hrrr("prompt","utils")." " ;     

00962            echo "&nbsp;".hrrr("str","utils")." " ;     

00963            echo "&nbsp;".hrrr("head","utils","tail()").", " ;     

00964            echo "&nbsp;".hrrr("savehistory","utils","history()")." " ;     

00965         } # fin si     

00966         if ($them=="fichiers") {     

00967            echo "&nbsp;".hrrr("read.table","utils","read.csv()")." " ;     

00968            echo "&nbsp;".hrrr("read.table","utils","read.csv2()")." " ;     

00969            echo "&nbsp;".hrrr("read.table","utils")." " ;     

00970            echo "&nbsp;".hrrr("write.table","utils","write.csv()")." " ;     

00971            echo "&nbsp;".hrrr("write.table","utils","write.csv2()")." " ;     

00972            echo "&nbsp;".hrrr("write.table","utils")." " ;     

00973         } # fin si     

00974         fintd() ;     

00975       fintr() ;     

00976     } # fin pour ;     

00977     fintable() ;     

00978     finblockquote() ;     

00979          

00980     p("texte") ;     

00981     echo "Dans le package " ;     

00982     echo hrrp("gdata").", il faut certainement connaitre les fonctions " ;     

00983     echo hrrr("combine","gdata").", " ;     

00984     echo hrrr("keep","gdata").", " ;     

00985     echo hrrr("ll","gdata").", " ;     

00986     echo hrrr("nobs","gdata").", " ;     

00987     echo hrrr("rename.vars","gdata").", " ;     

00988     echo hrrr("trim","gdata")." " ;     

00989     echo " et bien s&ucirc;r " ;     

00990     echo hrrr("read.xls","gdata").". " ;     

00991     finp() ;     

00992          

00993     p("texte") ;     

00994     echo "Enfin, dans le package " ;     

00995     echo hrrp("tools").", il faut certainement connaitre les fonctions " ;     

00996     echo hrrr("fileutils","tools","file_ext()").", " ;     

00997     echo hrrr("HTMLheader","tools","").", " ;     

00998     echo hrrr("Rd2HTML","tools","").", " ;     

00999     echo hrrr("showNonASCII","tools","").", " ;     

01000     echo hrrr("toHTML","tools","").". " ;     

01001     finp() ;     

01002          

01003          

01004     p("texte") ;     

01005     echo "Il n'y a aucun jeu de donn&eacute;es dans les packages ";     

01006     echo hrrp("tools") ;     

01007     echo " et " ;     

01008     echo hrrp("utils").". " ;     

01009     echo "Il n'y a plus aucun jeu de donn&eacute;es dans le package " ;     

01010     echo hrrp("base")."  " ;     

01011     echo " parce qu'ils ont tous &eacute;t&eacute; transf&eacute;r&eacute;s dans le package " ;     

01012     echo hrrp("datasets").". Voici les jeux de donn&eacute;es pr&eacute;sents dans ce package (version juillet 2013)&nbsp;:" ;     

01013     finp() ;     

01014          

01015     sortie_R("datasets_sor.txt") ;     

01016          

01017          

01018     p("texte") ;     

01019     echo "Le package " ;     

01020     echo hrrp("gdata")."  contient un seul jeu de donn&eacute;es, " ;     

01021     echo b("MedUnist").", dont l'aide indique " ;     

01022     echo em("&laquo;Table of conversions between Intertional Standard (SI) and US 'Conventional' Units for common medical measurements.&raquo;") ;     

01023     echo ". Le contenu de cette table de conversion est " ;     

01024     echo href("medunits_sor.txt","ici").". " ;     

01025     finp() ;     

01026          

01027     p("texte") ;     

01028     echo "Le package " ;     

01029     echo hrrp("foreign")."  est int&eacute;ressant parce que ses fonctions lisent (et &eacute;crivent parfois) les fichiers de donn&eacute;es " ;     

01030     echo " des autres grands logiciels statistiques comme Sas, Spss.. " ;     

01031     finp() ;     

01032          

01033     sortie_R("lls_foreign_sor.txt") ;     

01034          

01035     finsolution() ;     

01036          

01037     finblockquote() ;     

01038          

01039          

01040     ## -------------------------------------------------------------------------------------------     

01041          

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

01043          

01044     ?>
Listing du fichier intror2.php
