Code-source


00001     <?php     

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

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 = 3 ;     

00012     debutPageExercices($numSerie) ;     

00013          

00014     # le dernier &eacute;l&eacute;ment de v     

00015     # les trois derniers     

00016          

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

00018          

00019     p("texte") ;     

00020     echo "" ;     

00021     finp() ;     

00022     debutSection() ;     

00023          

00024     $tableauDesRubriques = array() ;     

00025     $idr = 0 ;     

00026          

00027     $idr++; $tableauDesRubriques[$idr] = "Comparaison de valeurs (1)" ;     

00028     $idr++; $tableauDesRubriques[$idr] = "Comparaison de valeurs (2)" ;     

00029     $idr++; $tableauDesRubriques[$idr] = "Filtrage vectoriel" ;     

00030     $idr++; $tableauDesRubriques[$idr] = "V&eacute;rification de valeurs dans un fichier Excel" ;     

00031     $idr++; $tableauDesRubriques[$idr] = "Remplacements dans un vecteur" ;     

00032     $idr++; $tableauDesRubriques[$idr] = "Utiliser AND ou imbriquer ?" ;     

00033     $idr++; $tableauDesRubriques[$idr] = "Fonctions &agrave; r&eacute;sultats logiques de $R" ;     

00034          

00035     $tdmCRLM = new tdm($tableauDesRubriques) ;     

00036     $tdmCRLM->titre() ;     

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

00038          

00039     afficherSolutions($numSerie) ;     

00040          

00041     finSection() ;     

00042          

00043     debutSection() ;     

00044     $numExo = 0 ;     

00045          

00046     ## -------------------------------------------------------------------------------------------     

00047          

00048     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; #  Comparaison de valeurs (1)     

00049          

00050     ## -------------------------------------------------------------------------------------------     

00051          

00052     blockquote() ;     

00053          

00054     blockquote() ;     

00055          

00056     p("texte") ;     

00057     echo "On dispose de deux variables nomm&eacute;es ".b("valA")." et ".b("valB").". " ;     

00058     echo " Sans utiliser les fonctions de $R, &eacute;crire des instructions qui mettent dans la variable " ;     

00059     echo b("petit")." la plus petite variable  (la variable de plus petit contenu) et dans " ;     

00060     echo b("grand")." la plus grande variable. " ;     

00061     echo " Donner ensuite la \"bonne\" solution avec les fonctions de $R. " ;     

00062     finp() ;     

00063          

00064     finblockquote() ;     

00065          

00066     solution($numExo,$numSerie) ;     

00067          

00068     p("texte") ;     

00069     echo "Un seul test logique suffit ici&nbsp;:" ;     

00070     finp() ;     

00071          

00072     pre_fichier("s3e1.txt","cadre") ;     

00073          

00074     finsolution() ;     

00075          

00076     finblockquote() ;     

00077          

00078     ## -------------------------------------------------------------------------------------------     

00079          

00080     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; #  Comparaison de valeurs (2)     

00081          

00082     ## -------------------------------------------------------------------------------------------     

00083          

00084     blockquote() ;     

00085          

00086     blockquote() ;     

00087          

00088     p("texte") ;     

00089     echo "On dispose de trois variables nomm&eacute;es ".b("valA").", ".b("valB")." et ".b("valC").". " ;     

00090     echo " Sans utiliser les fonctions de $R, &eacute;crire des instructions qui mettent dans la variable " ;     

00091     echo b("tpetit")." la plus petite variable, dans " ;     

00092     echo b("milieu")." la variable interm&eacute;diaire et dans " ;     

00093     echo b("tgrand")." la plus grande variable. " ;     

00094     echo " Donner ensuite la \"bonne\" solution avec les fonctions de $R. " ;     

00095     finp() ;     

00096          

00097     p("texte") ;     

00098     echo "Et si on avait plus de trois valeurs &agrave; trier&nbsp;?" ;     

00099     finp() ;     

00100          

00101     p("texte") ;     

00102     echo b("Remarque&nbsp;:") ;     

00103     echo " on supposera les valeurs distinctes. " ;     

00104     finp() ;     

00105          

00106     finblockquote() ;     

00107          

00108     solution($numExo,$numSerie) ;     

00109          

00110     p("texte") ;     

00111     echo "Ici, les choses se compliquent car il y a 6 cas &agrave; envisager..." ;     

00112     finp() ;     

00113          

00114     pre_fichier("s3e2.txt","cadre") ;     

00115          

00116          

00117     p("texte") ;     

00118     echo "La derni&egrave;re solution, qui met tous les &eacute;l&eacute;ments dans un vecteur et utilise " ;     

00119     echo lafonction("sort")." pour trier les &eacute;l&eacute;ments est la plus g&eacute;n&eacute;rale et couvre aussi le cas " ;     

00120     echo " de variables &eacute;gales. Ouf, pas besoin de faire 3, 4, 5... structures SI emboit&eacute;es&nbsp;!" ;     

00121     finp() ;     

00122          

00123     p("texte") ;     

00124     echo "On notera que pour v&eacute;rifier ces algorithmes on ne peut pas se contenter de v&eacute;rifier que cela " ;     

00125     echo " \"marche\" sur un exemple. Il faut bien tester les 6 cas avant d'&ecirc;tre s&ucirc;r de la " ;     

00126     echo " validit&eacute; de l'algorithme (ou du programme). Ainsi l'instruction \"tentante\" " ;     

00127     finp() ;     

00128          

00129     pre_fichier("s3e2plus.txt","cadre") ;     

00130          

00131     p("texte") ;     

00132     echo " met bien \"ce qu'il faut\" dans ".b("milieu")." dans 4 cas sur 6. Si on ne v&eacute;rifie pas tout, ce qui est " ;     

00133     echo rouge("fastidieux")." car il faut &ecirc;tre ".vert("exhaustif").", on risque de s'en rendre compte apr&egrave;s " ;     

00134     echo " avoir ex&eacute;cut&eacute; le programme plusieurs fois et avoir utilis&eacute; de faux r&eacute;sultats." ;     

00135     finp() ;     

00136          

00137     p("texte") ;     

00138     echo "Pour les plus courageux et les plus courageuses, on pourra essayer de refaire cet exercice " ;     

00139     echo " si on ajoute un ou plusieurs ".b("NA")." dans le vecteur..." ;     

00140     finp() ;     

00141          

00142     finsolution() ;     

00143          

00144     finblockquote() ;     

00145          

00146     ## -------------------------------------------------------------------------------------------     

00147          

00148     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; #  Filtrage vectoriel     

00149          

00150     ## -------------------------------------------------------------------------------------------     

00151          

00152     blockquote() ;     

00153          

00154     blockquote() ;     

00155          

00156     p("texte") ;     

00157     echo "Soit ".b("v")." le vecteur d&eacute;fini par &nbsp;" ;     

00158     finp() ;     

00159          

00160     pre("cadre demiLargeur") ;     

00161       echo " v  &lt;- c( 1, 8, 2, -5, 15, 6, 9, -1, 4) " ;     

00162     finpre() ;     

00163          

00164     p("texte") ;     

00165     echo "Donner les expressions $R qui fournissent&nbsp;:" ;     

00166     finp() ;     

00167          

00168     ul() ;     

00169          

00170     debutli() ; p() ;     

00171       echo "le dernier &eacute;l&eacute;ment de ".b("v")."&nbsp;;" ;     

00172     finp() ; finli() ;     

00173          

00174     debutli() ; p() ;     

00175       echo "les trois derniers &eacute;l&eacute;ments de ".b("v")."&nbsp;;" ;     

00176     finp() ; finli() ;     

00177          

00178     debutli() ; p() ;     

00179       echo "les &eacute;l&eacute;ments de ".b("v")." de rang pair." ;     

00180     finp() ; finli() ;     

00181          

00182     finul() ;     

00183          

00184     finblockquote() ;     

00185          

00186     solution($numExo,$numSerie) ;     

00187          

00188     p("texte") ;     

00189     echo "Puisque ".b("length(v)")." est &agrave; la fois la longueur et l'indice du dernier &eacute;l&eacute;ment de v, " ;     

00190     echo b("v[&nbsp;length(v)&nbsp;]")." est le dernier &eacute;l&eacute;ment de v." ;     

00191     finp() ;     

00192          

00193     p("texte") ;     

00194       echo "Pour les trois derniers &eacute;l&eacute;ments de ".b("v").", deux solutions au moins sont faciles &agrave; trouver&nbsp;:" ;     

00195     finp() ;     

00196          

00197     pre_fichier("s3e3.txt","cadre") ;     

00198          

00199     p("texte") ;     

00200     echo "Dans la mesure o&ugrave; $R dispose de l'op&eacute;rateur ".noir("%%")." qui renvoie le ".em("modulo").", c'est-&agrave;-dire le reste de la \n" ;     

00201     echo "division enti&egrave;re, les &eacute;l&eacute;ments de ".b("v")." de rang pair sont ".em("a priori")." donn&eacute;s par l'expression \n" ;     

00202     finp() ;     

00203          

00204     pre_fichier("rangpair1.txt","cadre") ;     

00205          

00206     p("texte") ;     

00207     echo "car \"pair\" &eacute;quivaut &agrave; \"dont le reste de la division par 2 est z&eacute;ro\". \n" ;     

00208     echo "Toutefois cette expression est peu lisible et certainement peu compr&eacute;hensible, sauf &agrave; bien connaitre la priorit&eacute; entre op&eacute;rateurs. \n" ;     

00209     echo "Ajouter des parenth&egrave;ses ne simplifie en rien l'expression&nbsp;: \n" ;     

00210     finp() ;     

00211          

00212     pre_fichier("rangpair2.txt","cadre") ;     

00213          

00214     p("texte") ;     

00215     echo "Il est au final beaucoup plus lisible d'&eacute;crire cela en plusieurs affectations&nbsp;:" ;     

00216     finp() ;     

00217          

00218     pre_fichier("rangpair3.txt","cadre") ;     

00219          

00220          

00221     p("texte") ;     

00222     echo "Attention &agrave; la notation ".b("1:length(v)")." car elle r&eacute;serve des suprises si le vecteur est de longueur nulle. " ;     

00223     echo " On lui pr&eacute;f&egrave;re en g&eacute;n&eacute;ral la fonction ".b("seq_along()")."&nbsp;:" ;     

00224     finp() ;     

00225          

00226     pre_fichier("seqalong.txt","cadre") ;     

00227          

00228     finsolution() ;     

00229          

00230     finblockquote() ;     

00231          

00232     ## -------------------------------------------------------------------------------------------     

00233          

00234     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; #  V&eacute;rification de valeurs dans un fichier Excel     

00235          

00236     ## -------------------------------------------------------------------------------------------     

00237          

00238     blockquote() ;     

00239          

00240     blockquote() ;     

00241          

00242     p("texte") ;     

00243     echo "On veut lire le fichier Excel nomm&eacute; ".href("elfNA.xls") ;     

00244     echo " et savoir combien de cases sont non vides pour la colonne AGE. " ;     

00245     echo " Comment r&eacute;aliser cela avec $R&nbsp;?" ;     

00246     finp() ;     

00247          

00248     finblockquote() ;     

00249          

00250     solution($numExo,$numSerie) ;     

00251          

00252     p("texte") ;     

00253     echo "Une case vide correspond &agrave; la valeur NA. Il suffit donc d'&eacute;crire&nbsp;:" ;     

00254     finp() ;     

00255          

00256     pre_fichier("s3e4.txt","cadre") ;     

00257          

00258     p("texte") ;     

00259     echo "On remarquera que la deuxi&egrave;me solution n'utilise pas de test logique en apparence. " ;     

00260     finp() ;     

00261          

00262     finsolution() ;     

00263          

00264     finblockquote() ;     

00265          

00266     ## -------------------------------------------------------------------------------------------     

00267          

00268     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Remplacements dans un vecteur     

00269          

00270     ## -------------------------------------------------------------------------------------------     

00271          

00272     blockquote() ;     

00273          

00274     blockquote() ;     

00275          

00276     p("texte") ;     

00277     echo "On voudrait convertir les cases non vides de la colonne AGE et remplacer par \"jeune\" " ;     

00278     echo " tout AGE&lt;20 et par \"vieux\" sinon. Quel code $R faut-il &eacute;crire&nbsp;?" ;     

00279     finp() ;     

00280          

00281     p("texte") ;     

00282     echo "Reprendre ensuite avec \"jeune\" " ;     

00283     echo " pour AGE&lt;20, \"adulte\" pour AGE entre 20 et 60 (bornes incluses) et \"vieux\" pour AGE>60." ;     

00284     finp() ;     

00285          

00286     p("texte") ;     

00287     echo "On pourra simuler 50 nombres entiers entre 1 et 99 pour AGE &agrave; l'aide de l'expression&nbsp;:" ;     

00288     finp() ;     

00289          

00290     pre_fichier("simulage.r","cadre") ;     

00291          

00292     finblockquote() ;     

00293          

00294     solution($numExo,$numSerie) ;     

00295          

00296     p("texte") ;     

00297     echo "$R est riche en fonctions. Si une solution avec ".hrrr("ifelse")." convient pour deux valeurs, "  ;     

00298     echo " il faut avoir recours &agrave; ".hrrr("cut")." pour plus de deux modalit&eacute;s, sachant que le remplacement " ;     

00299     echo " par filtre vectoriel est sans doute plus simple &agrave; lire&nbsp;:" ;     

00300     finp() ;     

00301          

00302     pre_fichier("s3e6.txt","cadre") ;     

00303          

00304     p("texte") ;     

00305     echo rouge("Remarques&nbsp;").": " ;     

00306     echo "lorsque la fonction ".hrrr("ifelse")." rencontre ".b("NA").", elle renvoie ".b("NA").". " ;     

00307     echo " Si on ne fournit pas de ".b("labels")." &agrave; la fonction ".hrrr("cut").", elle utilise les bornes de classes " ;     

00308     echo " comme labels o&ugrave; les parenth&egrave;ses signifient ".b("borne non comprise") ;     

00309     echo " alors que les crochets signifient ".b("borne comprise")." comme dans&nbsp;:" ;     

00310     finp() ;     

00311          

00312     pre_fichier("s3e7.txt","cadre") ;     

00313          

00314     finsolution() ;     

00315          

00316     finblockquote() ;     

00317          

00318     ## -------------------------------------------------------------------------------------------     

00319          

00320     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Utiliser AND ou imbriquer ?     

00321          

00322     ## -------------------------------------------------------------------------------------------     

00323          

00324     blockquote() ;     

00325          

00326     blockquote() ;     

00327          

00328     p("texte") ;     

00329     echo "En logique math&eacute;matique, on apprend que ".noir("a ET b")."  est &eacute;quivalent &agrave; \n" ;     

00330     echo noir("b ET a")." . Est-ce que pour $R  les codes ".noir("a &amp; b")."  et \n" ;     

00331     echo noir("b &amp; a")."  sont &eacute;quivalents&nbsp;? Comment le prouver ou au contraire \n" ;     

00332     echo "l'infirmer, sachant que  ".noir("a")."  et ".noir("b")."  sont des expressions $R&nbsp;? \n" ;     

00333     echo "Quelle est la diff&eacute;rence entre  ".noir("&amp;")."  et ".noir("&amp;&amp;")."  en $R&nbsp; ? \n" ;     

00334     echo " \n" ;     

00335     finp() ;     

00336          

00337     finblockquote() ;     

00338          

00339     solution($numExo,$numSerie) ;     

00340          

00341     p("texte") ;     

00342     echo " La logique math&eacute;matique et le traitement des expressions logiques en informatique sont tr&egrave;s proches mais diff&eacute;rents. " ;     

00343     echo " Math&eacute;matiquement,  pour &eacute;valuer ".noir("a ET b").", on &eacute;value  ".noir("a")."  puis on &eacute;value  ".noir("b")." " ;     

00344     echo " et enfin on effectue le ".noir("ET")."  logique sur les deux r&eacute;sultats pr&eacute;c&eacute;dents d'&eacute;valuation." ;     

00345     finp() ;     

00346          

00347     p("texte") ;     

00348     echo "C'est exactement ce que fait $R  quand il rencontre  ".noir("a &amp; b")."." ;     

00349     echo " Par contre, l'&eacute;valuation du code  ".noir("a &amp;&amp; b")."  se fait sur le mode ".em("coupe-circuit")."&nbsp;:" ;     

00350     echo " si ".noir("a")."  renvoie ".noir("FAUX").", ce n'est pas la peine d'&eacute;valuer ".noir("b")."  parce que ".noir("FAUX")."  et n'importe quoi " ;     

00351     echo " renvoie toujours ".noir("FAUX").". Donc  les expressions ".noir("a &amp;&amp; b")."  et ".noir("b &amp;&amp; a")."  ne sont pas strictement &eacute;quivalentes " ;     

00352     echo " alors que  ".noir("a &amp; b")."  et ".noir("b &amp; a")."  sont \"assez\" &eacute;quivalentes pour des expressions simples." ;     

00353     finp() ;     

00354          

00355     p("texte") ;     

00356     echo "Il faut donc plutot interpr&eacute;ter le code" ;     

00357     finp() ;     

00358          

00359     pre_fichier("if1.txt","cadre") ;     

00360          

00361     p("texte") ;     

00362     echo "comme le code suivant, avec une imbrication, o&ugrave; on voit bien qu'il n'y a pas sym&eacute;trie d'utilisation " ;     

00363     echo " entre ".noir("a")."  et ".noir("b")."&nbsp;:" ;     

00364     finp() ;     

00365          

00366     pre_fichier("if2.txt","cadre") ;     

00367          

00368     p("texte") ;     

00369     echo "C'est pourquoi vous ne devez ".rouge("jamais")."  utiliser ".noir("&amp;&amp;")."  avec des vecteurs, comme le montre le code suivant, " ;     

00370     echo " sous peine d'obtenir non pas un vecteur de r&eacute;sultats logiques calcul&eacute;s terme &agrave; terme mais juste une seule valeur " ;     

00371     echo "logique &nbsp;:" ;     

00372     finp() ;     

00373          

00374     pre_fichier("etet.txt","cadre") ;     

00375          

00376     p("texte") ;     

00377     echo "Si maintenant ".noir("a")."  et ".noir("b")."  sont des appels de fonctions qui modifient des variables globales " ;     

00378     echo " (il s'agit bien " ;     

00379     echo "s&ucirc;r ici d'une ".b("h&eacute;r&eacute;sie")." qui m&eacute;rite le b&ucirc;cher, mais cela risque peut-&ecirc;tre un jour de vous arriver, donc " ;     

00380     echo " autant le savoir pour mieux l'&eacute;viter), alors il y a encore " ;     

00381     echo " moins &eacute;quivalence entre  ".noir("a &amp; b")."  et ".noir("b &amp; a")."  comme le montre le code suivant " ;     

00382     echo " o&ugrave;  ".noir("a")."  correspond &agrave; l'appel de  ".noir("f()") ;     

00383     echo " et ".noir("b")."  &agrave; celui de ".noir("g()")."&nbsp;:" ;     

00384     finp() ;     

00385          

00386     pre_fichier("if3.r","cadre") ;     

00387          

00388     p("texte") ;     

00389     echo "Voici le r&eacute;sultat de son ex&eacute;cution -- si vous ne le saviez pas, l'expression ".noir("&lt;&lt;-")."  utilise l'environnement parent, donc ici " ;     

00390     echo "".noir("x")."  est une variable globale &nbsp;:" ;     

00391     finp() ;     

00392          

00393     pre_fichier("if3.txt","cadre") ;     

00394          

00395     p("texte") ;     

00396     echo " On voit clairement qu'avec ".noir("&amp;")."  les deux fonctions sont appel&eacute;es alors qu'avec " ;     

00397     echo "".noir("&amp;&amp;")."  seule la premi&egrave;re fonction est utilis&eacute;e. De plus &agrave; chaque fois " ;     

00398     echo " on n'obtient pas le m&ecirc;me r&eacute;sultat suivant qu'on commence par  ".noir("a")."  ou par ".noir("b")."." ;     

00399     finp() ;     

00400          

00401     finsolution() ;     

00402          

00403     finblockquote() ;     

00404          

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

00406          

00407     $tdmCRLM->afficheRubrique("oui") ; $numExo++ ; # Fonctions &agrave; r&eacute;sultats logiques de $R     

00408          

00409     ## -------------------------------------------------------------------------------------------     

00410          

00411     blockquote() ;     

00412          

00413     blockquote() ;     

00414          

00415     p("texte") ;     

00416     echo " Comment fait-on en $R  pour tester si un mot est pr&eacute;sent dans une liste de mots ou dans un vecteur " ;     

00417     echo " de mots avec ".lafonction("grep")."&nbsp;? Et avec l'op&eacute;rateur ".noir("%in%")."&nbsp;?" ;     

00418     finp() ;     

00419          

00420     p("texte") ;     

00421     echo " On veut savoir si au moins un des &eacute;l&eacute;ments du vecteur ".noir("V")."  num&eacute;rique ";     

00422     echo " est positif. Trouver une solution bas&eacute;e sur ".noir("V>0")."  et ".noir("sum").". Pourquoi " ;     

00423     echo " ".lafonction("any")."  est-elle plus adapt&eacute;e&nbsp;?" ;     

00424     finp() ;     

00425          

00426     p("texte") ;     

00427     echo " On veut &ecirc;tre s&ucirc;r que tous les &eacute;l&eacute;ments du vecteur ".noir("V")."  num&eacute;rique " ;     

00428     echo " sont positifs. Trouver une solution bas&eacute;e sur ".noir("V>0").", ".noir("sum")." et ".noir("length(V)").". ";     

00429     echo " Pourquoi ".lafonction("all")." est-elle plus adapt&eacute;e&nbsp;?" ;     

00430     finp() ;     

00431          

00432     p("texte") ;     

00433     echo " A quoi sert ".lafonction("all.equal")."&nbsp;?" ;     

00434     finp() ;     

00435          

00436     finblockquote() ;     

00437          

00438     solution($numExo,$numSerie) ;     

00439          

00440     p("texte") ;     

00441     echo " La fonction ".hrrr("grep")." permet de connaitre la ou les positions d'un mot dans une liste ou dans un vecteur de mots " ;     

00442     echo " comme on peut le voir avec le r&eacute;sultat d'ex&eacute;cution ci-dessous&nbsp;:" ;     

00443     finp() ;     

00444          

00445     pre_fichier("grep1.txt","cadre") ;     

00446          

00447     p("texte") ;     

00448     echo " Le premier r&eacute;sultat renvoy&eacute; est ".noir("1 4")."  parce que \"le\" est trouv&eacute; comme premier et quatri&egrave;me mot dans la liste ".noir("ldm").". " ;     

00449     echo " Le deuxi&egrave;me r&eacute;sultat renvoy&eacute; montre que ".hrrr("grep")."  sait aussi rechercher des sous-chaines&nbsp;: " ;     

00450     echo " le vecteur r&eacute;sultat ".noir("2 5") ;     

00451     echo " signifie que \"ch\" est trouv&eacute; dans les deuxi&egrave;me et cinqui&egrave;me mots du vecteur ".noir("ldm[[1]]").". " ;     

00452     echo hrrr("grep")." sait utiliser les " ;     

00453     echo href("../../../tuteurs/tutregexp.php","expressions r&eacute;guli&egrave;res") ;     

00454     echo "&nbsp;: le troisi&egrave;me r&eacute;sultat indique que les mots 2 et 3 " ;     

00455     echo " finissent par \"t\", ce qui se d&eacute;crit par l'expression r&eacute;guli&egrave;re ".noir("t\$")."." ;     

00456     finp() ;     

00457          

00458     p("texte") ;     

00459     echo " Lorsque ".lafonction("grep")." ne trouve pas ce qu'on cherche, elle renvoie " ;     

00460     echo b("integer(0)")."  c'est-&agrave;-dire un vecteur de longueur 0. Il suffit donc " ;     

00461     echo " d'&eacute;crire ".noir("if (length(grep(...)&gt;0)")."  pour savoir si la recherche a &eacute;t&eacute; fructueuse." ;     

00462     finp() ;     

00463          

00464     p("texte") ;     

00465     echo " Si on veut juste v&eacute;rifier que le mot est exactement pr&eacute;sent dans un vecteur, on peut utiliser " ;     

00466     echo " l'op&eacute;rateur ".hrrr("match","base","%in%")."&nbsp;:" ;     

00467     finp() ;     

00468          

00469     pre_fichier("grep2.txt","cadre") ;     

00470          

00471     p("texte") ;     

00472     echo " Dans les exercices de la s&eacute;ance 8, on montrera que ".noir("%in%")."  est vraiment beaucoup plus rapide que  ".hrrr("grep").". " ;     

00473     finp() ;     

00474          

00475     p("texte") ;     

00476     echo " Pour savoir si au moins un des &eacute;l&eacute;ments du vecteur ".noir("V")."  num&eacute;rique est positif, on peut se contenter, pour des " ;     

00477     echo " vecteurs de petite longueur, de l'expression ".noir("if (sum(V&gt;0)&gt;0)").". " ;     

00478     echo " En effet,  ".noir("V&gt;0")."  renvoie un ensemble de valeurs logiques " ;     

00479     echo " ".noir("TRUE")."  et ".noir("FALSE")."  remplac&eacute;s automatiquement par ".noir("1")."  et ".noir("0")."  &agrave; cause de l'appel de ".noir("sum()").". " ;     

00480     echo " S'il y a au moins un &eacute;l&eacute;ment positif, il y a au moins un ".noir("TRUE")."  donc au moins un 1, et la somme est forc&eacute;ment positive." ;     

00481     finp() ;     

00482          

00483     p("texte") ;     

00484     echo " Cette solution " ;     

00485     echo " n'est pas optimis&eacute;e parce qu'on teste ".b("tous")."  les &eacute;l&eacute;ments de V. Avec un vecteur d'un million d'&eacute;l&eacute;ments tous n&eacute;gatifs sauf le " ;     

00486     echo " premier, on effectue un million de tests. " ;     

00487     echo " C'est pourquoi ".lafonction("any")." est plus adapt&eacute;e et sans doute plus rapide&nbsp;: " ;     

00488     echo " elle renvoie VRAI d&egrave;s qu'elle trouve un " ;     

00489     echo " &eacute;l&eacute;ment correspondant (mais sans dire o&ugrave;&nbsp;; c'est l'expression ".noir("which(V&gt;0)")."  qui en donne les positions)." ;     

00490     echo " Dans les exercices de la s&eacute;ance 8, on calculera &agrave; quel point ".noir("any(v&gt;0)")."  est plus rapide que  ".noir("sum(v&gt;0)&gt;0")."." ;     

00491     finp() ;     

00492          

00493     p("texte") ;     

00494     echo " De la m&ecirc;me fa&ccedil;on, tous les &eacute;l&eacute;ments de  ".noir("V")."   sont positifs si  ".noir("sum(v&gt;0)")."  est &eacute;gal &agrave; la longueur de ".noir("V").".  " ;     

00495     echo " On peut donc le tester via ".noir("if (sum(V&gt;0)==length(V))")."  pour des vecteurs de petite longueur ou prendre l'habitude d'utiliser d&egrave;s le d&eacute;part " ;     

00496     echo " ".noir("if (all(V&gt;0))")."." ;     

00497     finp() ;     

00498          

00499     p("texte") ;     

00500     echo " Comme son nom l'indique, ".lafonction("all.equal")." permet de tester si deux objets sont &eacute;gaux. Si vous vous souvenez bien, " ;     

00501     echo " au chapitre pr&eacute;c&eacute;dent, nous avions, dans le calcul des contributions relatives pour la comparaison d'effectifs observ&eacute;s et d'effectifs " ;     

00502     echo " th&eacute;oriques, " ;     

00503     echo " deux variables num&eacute;riquement &eacute;gales, mais l'une &eacute;tait nomm&eacute;e pas l'autre. " ;     

00504     echo " La fonction ".hrrr("all.equal")." est capable de l'indiquer&nbsp;:" ;     

00505     finp() ;     

00506          

00507     pre_fichier("allequal1.txt","cadre") ;     

00508          

00509     p("texte") ;     

00510     echo " De m&ecirc;me qu'elle peut d&eacute;tecter des diff&eacute;rences de longueur, de structure...&nbsp;:" ;     

00511     finp() ;     

00512          

00513     pre_fichier("allequal2.txt","cadre") ;     

00514          

00515     p("texte") ;     

00516     echo " Si vous pensez avoir construit deux variables compl&eacute;tement &eacute;quivalentes, surtout s'il s'agit de structures, ".hrrr("all.equal")."  " ;     

00517     echo " peut vous le dire ou expliquer ce qu'elle trouve de diff&eacute;rent... une fois qu'".hrrr("identical")." est pass&eacute; par l&agrave;, bien s&ucirc;r." ,     

00518     finp() ;     

00519          

00520          

00521     p("texte") ;     

00522     echo " Voici donc quelques autres d&eacute;tections obtenues gr&acirc;ce &agrave;  ".hrrr("all.equal")."&nbsp;:" ;     

00523     finp() ;     

00524          

00525     pre_fichier("allequal3.txt","cadre") ;     

00526          

00527     finsolution() ;     

00528          

00529     finblockquote() ;     

00530          

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

00532          

00533     ?>
Listing du fichier progie3.php
