1. Soulignés et encadrés
R affiche les informations en mode texte et ce n'est pas toujours facile de trouver
rapidement ce que l'on cherche dans les résultats d'exécution. Ecrire une fonction
nommée souligne() qui souligne un texte passé en paramètre avec le symbole égal par défaut
comme caractère de soulignement, ou avec un autre caractère passé en deuxième paramètre.
Serait-ce beaucoup plus difficile de réaliser un encadrement ?
Voici des exemples d'exécution pour illustrer ce qu'on voudrait réaliser.
> souligne("Analyse statistique")
Analyse statistique
===================
> souligne(texte="Analyse numéro 2",avec="-")
Analyse numéro 2
----------------
> encadre("Exercices de programmation")
+ ========================== +
+ +
+ Exercices de programmation +
+ +
+ ========================== +
Pour souligner, on peut se contenter d'afficher autant de caractères "égal" que le texte a
de caractères. Comme nchar(chaine) donne la longueur de la chaine, on doit donc
générer tous ces caractères avec
la fonction rep()
puis les mettre bout à bout
avec la fonction paste(), soit le code suivant où le paramètre avec désigne le
caractère de soulignement, dont = est la valeur par défaut :
#################################################################
souligne <- function(texte="",avec="=") {
#################################################################
lng <- nchar(texte)
cat("\n",texte,"\n")
cat(paste(rep(avec,lng),collapse=""),"\n\n")
} # fin de fonction souligne
Pour encadrer, c'est à peine plus compliqué, puisqu'il suffit de produire le soulignement avant et après le texte
et de rajouter un symbole en début et en fin de ligne. Comme nous utilisons deux fois les mêmes informations,
nous avons créé deux variables, ligneVide et lignePleine pour que ce soit plus facile à maintenir :
#################################################################
encadre <- function(texte="",avec="=") {
#################################################################
lng <- nchar(texte)
lignePleine <- paste(rep(avec,lng),collapse="")
ligneVide <- paste(rep(" ",lng), collapse="")
cat("\n")
cat("+",lignePleine,"+\n")
cat("+",ligneVide,"+\n")
cat("+",texte,"+\n")
cat("+",ligneVide,"+\n")
cat("+",lignePleine,"+\n")
} # fin de fonction encadre
2. Utilisation de sink() et source()
Comment fait-on pour exécuter du code R en mode session, avec Rstudio ou en ligne de commandes shell ? Quelles sont les options d'exécution ? Comment obtenir un fichier "log" qui contient une copie dans un fichier texte de tout ce qui a été affiché ?
Après avoir lu l'aide sur les fonctions sink() et source(), expliquer ce que réalise la fonction sinksource() suivante et comment on s'en sert :
#################################################################
sinksource <- function(fName,encoding="latin1",split=TRUE,...) {
#################################################################
# mais que diable fait cette fonction ?
baseName <- fName
lng <- nchar(fName)
if (substr(fName,lng-1,lng)==".r") {
baseName <- substr(fName,1,lng-2)
} # fin si
fs <- paste(baseName,".sor",sep="")
fp <- paste(baseName,".r",sep="")
unlink(fs)
sink(fs,split=split)
source(fp,encoding=encoding,print.eval=TRUE,...)
sink()
cat("\n\n vous pouvez utiliser ",fs,"\n")
} # fin de fonction sinksource
En mode session, on peut
-
saisir au clavier les instructions,
-
copier/coller des instructions venus d'un éditeur ou d'une page web,
-
exécuter les instructions d'un fichier avec source().
Avec Rstudio, on peut de plus exécuter le code du panneau Source.
En ligne de commandes shell on peut soit exécuter une expression avec l'option -e soit exécuter les instructions d'un fichier avec l'option -f.
Parmi les nombreux paramètres de source(), les paramètres echo, print.eval et verbose permettent de gérer l'affichage. Ainsi, avec echo=TRUE, R affiche chaque instruction avant de l'exécuter. Avec print.eval=TRUE R affiche chaque valeur calculée par affectation. Voir cela en action dans notre séance 2 d'introduction à R.
La lecture du texte d'aide de la fonction sink() explique que cette fonction permet de rediriger l'affichage vers un fichier. Avec le paramètre split=TRUE l'affichage est à la fois redirigé vers l'écran et le fichier.
Comme son nom l'indique, la fonction sinksource() réalise un sink() puis un source(). Elle vient ensuite fermer le fichier-sink. Dans la mesure où le nom du fichier résultat est construit à partir du nom du fichier programme, chaque programme source dispose de son fichier "log". Par exemple, si on exécute sinksource("test28") alors R exécute le fichier test28.r et tout ce qui est affiché à l'écran est automatiquement recopié dans le fichier test28_log.txt. L'ellipse est mise dans l'entête de la fonction pour qu'on puisse passer éventuellement des options comme echo=TRUE. On n'est pas obligé d'écrire .r à la fin du nom du fichier parce que la fonction détecte la présence ou l'absence de .r en fin de nom de fichier fourni et rajoute .r s'il le faut.
3. Une fonction pour attendre
On a de temps en temps besoin non pas d'interrompre mais de suspendre l'exécution et surtout l'affichage d'un programme, par exemple pour vérifier que les sorties correspondent à ce qu'on attendait. Ecrire une fonction attendre qui suspend le script, pose une question et continue le script si on appuie juste sur "Entrée" ou qui quitte le programme si on écrit quelque chose.
Voici une solution possible. On lit au clavier avec la fonction readline() et on arrête le script avec stop() :
#################################################################
attendre <- function(txt="") {
#################################################################
# on pose une question et si la réponse n'est pas <Entrée>, on quitte le programme en cours
# exemple : attendre("on continue (appuyer juste sur Entrée si OK)")
if (txt!="") {
cat(txt,"\n")
} # fin si
rep <- readline("ok ? ")
if (!rep=="") {
stop("Vous avez demandé d'arrêter ce programme.")
} # fin si
} # fin de fonction attendre
4. Reproduire la fonction ifelse
Afin de comprendre ce que fait la fonction R nommée ifelse(), écrire une fonction sialors qui utilise trois paramètres, condition, sioui, sinon et dont le comportement est le suivant :
> ages <- c(10,50,8,20)
> sialors(ages<20,"jeune","vieux")
"jeune" "vieux" "jeune" "vieux"
> cbind( ages, sialors(ages<20,"jeune","vieux") )
[1,] "10" "jeune"
[2,] "50" "vieux"
[3,] "8" "jeune"
[4,] "20" "vieux"
On rajoutera un test sur les paramètres : ainsi sialors() sans paramètre devra afficher une aide avec le rappel de la syntaxe et des exemples, comme par exemple :
> sialors()
fonction sialors(condition,sioui,sinon)
on renvoie un vecteur avec "sioui ou "sinon"
en fonction de "condition".
exemple : sialors(ages<20,"jeune","vieux")
Peut-on consulter le code de la fonction ifelse() ?
Comme dit précédemment, il vaut mieux éviter les boucles, d'où une solution par filtrage vectoriel :
##########################################################################
sialors <- function(condition,sioui,sinon) {
##########################################################################
# renvoie un vecteur contenant les valeurs de "sioui" ou de "sinon"
# en fonction de "condition"
if (missing(condition)) {
cat("fonction sialors(condition,sioui,sinon) \n\n")
cat(" on renvoie un vecteur avec \"sioui\ ou \"sinon\" \n")
cat(" en fonction de \"condition\".\n\n")
cat(" exemple : sialors(ages<20,\"jeune\",\"vieux\")\n")
cat("\n")
return(invisible(NULL))
} # fin si
nbElt <- length(condition) # nombre d'éléments
# initialisaton
vectRes <- rep(NA,nbElt) # vecteur résultat
vectOui <- rep(sioui,nbElt) # vecteur résultat si Oui
vectNon <- rep(sinon,nbElt) # vecteur résultat si Non
# remplissage
vectRes[ condition ] <- vectOui[ condition ]
vectRes[ !condition ] <- vectNon[ !condition ]
return( vectRes )
} # fin de fonction sialors
Pour consulter le code source de la fonction ifelse()il suffit de taper son nom, sans les parenthèses :
# affichage du code source de la fonction ifelse()
> ifelse # ou : print(ifelse)
function (test, yes, no)
{
if (is.atomic(test)) {
if (typeof(test) != "logical")
storage.mode(test) <- "logical"
if (length(test) == 1 && is.null(attributes(test))) {
if (is.na(test))
return(NA)
else if (test) {
if (length(yes) == 1 && is.null(attributes(yes)))
return(yes)
}
else if (length(no) == 1 && is.null(attributes(no)))
return(no)
}
}
else test <- if (isS4(test))
as(test, "logical")
else as.logical(test)
ans <- test
ok <- !(nas <- is.na(test))
if (any(test[ok]))
ans[test & ok] <- rep(yes, length.out = length(ans))[test &
ok]
if (any(!test[ok]))
ans[!test & ok] <- rep(no, length.out = length(ans))[!test &
ok]
ans[nas] <- NA
ans
}
<bytecode: 0x25113f0>
<environment: namespace:base>
>
5. Une fonction anonyme pour gérer les NA ?
On voudrait calculer les moyennes des colonnes d'un data frame sachant qu'il y a des valeurs NA, comme par exemple pour les données des colonnes 2 à 4 du fichier diabete.dar. Montrer que l'utilisation d'une fonction anonyme suffit. Peut-on s'en passer ?
Effectivement faire un apply() de la fonction mean() ne renvoie pas le résultat attendu. Du coup, écrire une fonction anonyme à la volée est tentant :
# lecture de données sur Internet
url <- "http://forge.info.univ-angers.fr/~gh/wstat/Introduction_R/diabete.dar"
diaTout <- read.table(url,header=TRUE,row.names=1)
# on se restreint aux colonnes 2 à 4, qui contiennent des NA
dia <- diaTout[,(2:4)]
# on ne peut pas calculer la moyenne à cause des NA
cat("Moyenne en colonne, version 1\n")
print(res <- apply(X=dia,MARGIN=2,FUN=mean) ) # les parenthèses forcent l'affichage
# on utilise une fonction anonyme définie "juste au passage"
cat("Moyenne en colonne, version 2\n")
print(res <- apply(X=dia,MARGIN=2,FUN=function(x) { return(mean(x,na.rm=TRUE)) } ) )
#### on aurait pu se contenter de
####
#### (res <- apply(X=dia,MARGIN=2,FUN=function(x) mean(x,na.rm=TRUE)) )
####
Moyenne en colonne, version 1
chol stab.glu hdl
NA 106.6725 NA
Moyenne en colonne, version 2
chol stab.glu hdl
207.84577 106.67246 50.44527
Mais ce serait méconnaitre R : sapply est capable de prendre des paramètres supplémentaires. De plus, R dispose déjà d'une fonction pour ce calcul très classique, c'est la fonction colMeans() :
# lecture de données sur Internet
url <- "http://forge.info.univ-angers.fr/~gh/wstat/Introduction_R/diabete.dar"
diaTout <- read.table(url,header=TRUE,row.names=1)
# on se restreint aux colonnes 2 à 4, qui contiennent des NA
dia <- diaTout[,(2:4)]
# moyennes en colonne sans fonction anonyme mais passage de paramètre supplémentaire
cat("Moyenne en colonne, version 3\n")
print( res <- apply(X=dia,MARGIN=2,FUN=mean,na.rm=TRUE) )
# la bonne solution : moyennes en colonne avec colMeans
cat("Moyenne en colonne, version 4\n")
print( res <- colMeans(dia,na.rm=TRUE) )
Moyenne en colonne, version 3
chol stab.glu hdl
207.84577 106.67246 50.44527
Moyenne en colonne, version 4
chol stab.glu hdl
207.84577 106.67246 50.44527
6. Formater l'affichage d'un data frame
R sait assez bien formater une matrice de résultats numériques parce que toutes les colonnes sont numériques. Afficher "proprement" (avec un format particulier pour chaque colonne) un data.frame n'est vraiment prévu en R. Implémenter une fonction printdf qui prend en entrée deux paramètres df et fmt. df est bien sûr un data frame et fmt le format de chaque colonne au sens de sprintf().
Voici ce qu'on veut obtenir par exemple :
> data(cars)
> print( head(cars) )
speed dist
1 4 2
2 4 10
3 7 4
4 7 22
5 8 16
6 9 10
> printdf( head(cars),c("%02d","%5.1f") )
speed dist
1 04 2.0
2 04 10.0
3 07 4.0
4 07 22.0
5 08 16.0
6 09 10.0
Puisque R est vectoriel, la réponse tient en une ligne : il suffit d'utiliser sapply().
##########################################################################
printdf <- function(df,fmt) {
##########################################################################
# on applique sprintf(fmt[i]) à chaque colonne i du df
if (missing(df)) {
cat("fonction df(data.frame,formats_colonne) \n\n")
cat(" on renvoie le data frame formaté via sprintf en colonne\n\n")
cat(" exemple : printdf( cars,c(\"%02d\",\"%5.1f\") )\n")
cat("\n")
return(invisible(NULL))
} # fin si
newDf <- data.frame(sapply(FUN = function(i,x,y) sprintf(x[i],y[,i]),X=1:length(df),fmt,df))
names(newDf) <- names(df)
row.names(newDf) <- row.names(df)
return( newDf )
} # fin de fonction printdf
Voici des exemples d'utilisation :
# chargement du code source de printdf
source("printdf.r",encoding="latin1")
# vérifions que l'aide s'affiche
printdf()
## exemple 1
data(cars)
row.names(cars) <- paste("voiture",sprintf("%d",1:6),sep="")
printdf( head(ccars),c("%02d","%5.1f") )
## exemple 2
source("http://www.info.univ-angers.fr/~gh/statgh.r",encoding="latin1")
elf <- lit.dar("http://www.info.univ-angers.fr/~gh/Datasets/elf.dar")
modEtud <- c("NR","Primaire","Secondaire","Bac","Sup")
elf$SEXE <- factor(elf$SEXE,levels=0:1,labels=c("Homme","Femme"))
elf$ETUD <- factor(elf$ETUD,levels=0:4,labels=modEtud)
eelf <- head( elf[,c("SEXE","AGE","ETUD")] )
Explications :
Pour trouver cette solution, on peut commencer par essayer de résoudre le problème d'appliquer le i-ème format à la i-ème colonne du data frame. C'est très simple puisque la fonction sprintf() est vectorielle. On écrit donc sprintf(fmt[i],df[,i]). Ensuite, il faut appliquer cela à toutes les colonnes. Une solution avec une boucle POUR sur i est possible, bien sûr mais nous savons qu'il vaut mieux éviter les boucles POUR. Il reste donc la solution avec sapply().
Comme la fonction sapply() applique une fonction, il faut inventer celle qui à partir de i, fmt et df applique sprintf(fmt[i]) à la colonne i de df. On peut écrire une fonction nommée, par exemple formatCol soit localement soit globalement :
# printdf avec une fonction globale formatCol
# ------------------------------------------
formatCol <- function(i,x,y) {
return( sprintf(x[i],y[,i])
} # fin de fonction formatCol
printdf <- function(df,fmt) {
[...] # code de printdf
} # fin de fonction printdf
# printdf avec une fonction locale formatCol
# ------------------------------------------
printdf <- function(df,fmt) {
formatCol <- function(i,x,y) {
return( sprintf(x[i],y[,i])
} # fin de fonction formatCol
[...] suite du code de printdf
} # fin de fonction printdf
Une autre solution consiste à définir une fonction anonyme directement à la suite de FUN= dans l'appel de sapply. C'est la solution que nous avons choisie car formatCol présente peu d'intérêt en dehors de printdf.
La notion récente (2016) de tibble se veut un remplacement "propre" (tidy en anglais) des data.frame, notamment pour ces problèmes de format d'affichage. On lira avec intérêt le document en français R et tidyverse de J. BARNIER que nous remercions au passage pour ce document.
7. Bien afficher par() et options()
La commande par() donne, avec un affichage peu agréable, tous les paramètres graphiques. Ecrire une fonction parPrint() qui les affiche par ordre alphabétique et dont voici un exemple d'affichage (tronqué) :
Paramètre Longueur Valeur
[1,] adj 1 0.5
[2,] ann 1 TRUE
[3,] ask 1 FALSE
[4,] bg 1 white
[5,] bty 1 o
[6,] cex 1 1
[7,] cex.axis 1 1
...
[69,] yaxt 1 s
[70,] ylbias 1 0.1
[71,] ylog 1 FALSE
Utilisez la même stratégie pour la commande options() ; on écrira une fonction optionsPrint() qui pourra trier par type d'information fournie ; en voici deux exemples d'affichage (tronqué) :
Toutes les options par ordre alphabétique
=========================================
Option Type Longueur Valeur
[1,] add.smooth logical 1 TRUE
[2,] bitmapType character 1 cairo
[3,] browser closure 1 <<function...>>
[4,] browserNLdisabled logical 1 FALSE
...
[45,] str list 3 strict.width=no digits.d=3 vec.len=4
...
[54,] warn double 1 0
[55,] warning.length integer 1 1000
[56,] width integer 1 150
Toutes les options par type puis par ordre alphabétique
=======================================================
Option Type Longueur Valeur
[1,] bitmapType character 1 cairo
[2,] continue character 1 +
[3,] contrasts character 2 contr.treatment contr.poly
[4,] defaultPackages character 6 datasets utils grDevices graphics stats methods
...
[26,] unzip character 1 /usr/bin/unzip
[27,] browser closure 1 <<function...>>
[28,] internet.info double 1 2
...
[34,] digits integer 1 7
[35,] expressions integer 1 5000
...
[38,] width integer 1 150
[39,] str list 3 strict.width=no digits.d=3 vec.len=4
[40,] add.smooth logical 1 TRUE
...
Voici une implémentation d'une fonction pour visualiser tous les paramètres graphiques et son affichage complet :
parPrint <- function() {
# mieux que : print( par() )
# sachant que ni sort( par() ) ni order( par() ) ne fonctionnent
lesPg <- par()
nomPg <- names(lesPg)
idx <- order(nomPg)
nbElt <- length(lesPg)
matPg <- matrix(nrow=nbElt,ncol=3)
colnames(matPg) <- c("Paramètre","Longueur","Valeur")
for (idp in 1:nbElt) {
jdp <- idx[idp]
matPg[idp,1] <- nomPg[jdp]
eltPg <- lesPg[[jdp]]
lngElt <- length(eltPg)
matPg[idp,2] <- lngElt
if (lngElt==1) {
if (is.na(eltPg)) {
eltPg <- "<<NA>>"
} # finsi
if (is.null(eltPg)) {
eltPg <- "<<nul>>"
} # finsi
if (eltPg=="") {
eltPg <- "<<vide>>"
} # finsi
matPg[idp,3] <- eltPg
} else {
if (is.numeric(eltPg)) {
eltPg <- round(eltPg,2)
} # finsi
strValeurPg <- ghtrim(paste(eltPg,collapse=" "))
matPg[idp,3] <- strValeurPg
} # fin si
} # fin pour idp
print(matPg,quote=FALSE)
} # fin de fonction parPrint
Paramètre Longueur Valeur
[1,] adj 1 0.5
[2,] ann 1 TRUE
[3,] ask 1 FALSE
[4,] bg 1 white
[5,] bty 1 o
[6,] cex 1 1
[7,] cex.axis 1 1
[8,] cex.lab 1 1
[9,] cex.main 1 1.20000004768372
[10,] cex.sub 1 1
[11,] cin 2 0.15 0.2
[12,] col 1 black
[13,] col.axis 1 black
[14,] col.lab 1 black
[15,] col.main 1 black
[16,] col.sub 1 black
[17,] cra 2 10.8 14.4
[18,] crt 1 0
[19,] csi 1 0.2
[20,] cxy 2 0.01 0.02
[21,] din 2 14 12.26
[22,] err 1 0
[23,] family 1 <<vide>>
[24,] fg 1 black
[25,] fig 4 0 1 0 1
[26,] fin 2 14 12.26
[27,] font 1 1
[28,] font.axis 1 1
[29,] font.lab 1 1
[30,] font.main 1 2
[31,] font.sub 1 1
[32,] lab 3 5 5 7
[33,] las 1 0
[34,] lend 1 round
[35,] lheight 1 1
[36,] ljoin 1 round
[37,] lmitre 1 10
[38,] lty 1 solid
[39,] lwd 1 1
[40,] mai 4 1.02 0.82 0.82 0.42
[41,] mar 4 5.1 4.1 4.1 2.1
[42,] mex 1 1
[43,] mfcol 2 1 1
[44,] mfg 4 1 1 1 1
[45,] mfrow 2 1 1
[46,] mgp 3 3 1 0
[47,] mkh 1 0.001
[48,] new 1 FALSE
[49,] oma 4 0 0 0 0
[50,] omd 4 0 1 0 1
[51,] omi 4 0 0 0 0
[52,] pch 1 1
[53,] pin 2 12.76 10.42
[54,] plt 4 0.06 0.97 0.08 0.93
[55,] ps 1 12
[56,] pty 1 m
[57,] smo 1 1
[58,] srt 1 0
[59,] tck 1 <<NA>>
[60,] tcl 1 -0.5
[61,] usr 4 0 1 0 1
[62,] xaxp 3 0 1 5
[63,] xaxs 1 r
[64,] xaxt 1 s
[65,] xlog 1 FALSE
[66,] xpd 1 FALSE
[67,] yaxp 3 0 1 5
[68,] yaxs 1 r
[69,] yaxt 1 s
[70,] ylbias 1 0.1
[71,] ylog 1 FALSE
Comme code d'une fonction qui affiche toutes les options de la configuration de R, nous vous proposons
optionsPrint <- function(triType=FALSE) {
# mieux que options()
# sachant que ni sort( options() ) ni order( options() ) ne fonctionnent
lesOpt <- options()
leso <- options()
nomOpt <- names(lesOpt)
typOpt <- lapply(X=lesOpt,FUN=typeof)
if (triType) {
idx <- order(unlist(unname(as.vector(typOpt))),nomOpt)
} else {
idx <- order(nomOpt)
} # finsi
nbElt <- length(lesOpt)
matOpt <- matrix(nrow=nbElt,ncol=4)
colnames(matOpt) <- c("Option","Type","Longueur","Valeur")
for (idp in 1:nbElt) {
jdp <- idx[idp]
matOpt[idp,1] <- nomOpt[jdp]
eltOpt <- lesOpt[[jdp]]
lngElt <- length(eltOpt)
matOpt[idp,2] <- typeof(eltOpt)
matOpt[idp,3] <- lngElt
if (typeof(eltOpt)=="closure") {
matOpt[idp,4] <- "<<function...>>"
} else if (typeof(eltOpt)=="list") {
matOpt[idp,4] <- paste(names(eltOpt),eltOpt,sep="=",collapse=" ")
} else {
if (lngElt==1) {
if (is.na(eltOpt)) {
eltOpt <- "<<NA>>"
} # finsi
if (is.null(eltOpt)) {
eltOpt <- "<<nul>>"
} # finsi
if (eltOpt=="") {
eltOpt <- "<<vide>>"
} # finsi
matOpt[idp,4] <- eltOpt
} else {
if (is.numeric(eltOpt)) {
eltOpt <- round(eltOpt,2)
} # finsi
strValeurPg <- ghtrim(paste(eltOpt,collapse=" "))
matOpt[idp,4] <- strValeurPg
} # fin si
} # fin si
} # fin pour idp
print(matOpt,quote=FALSE)
} # fin de fonction optionsPrint
Toutes les options par ordre alphabétique
=========================================
Option Type Longueur Valeur
[1,] add.smooth logical 1 TRUE
[2,] bitmapType character 1 cairo
[3,] browser closure 1 <<function...>>
[4,] browserNLdisabled logical 1 FALSE
[5,] check.bounds logical 1 FALSE
[6,] continue character 1 +
[7,] contrasts character 2 contr.treatment contr.poly
[8,] defaultPackages character 6 datasets utils grDevices graphics stats methods
[9,] demo.ask character 1 default
[10,] device character 1 RStudioGD
[11,] device.ask.default logical 1 FALSE
[12,] digits integer 1 7
[13,] dvipscmd character 1 dvips
[14,] echo logical 1 TRUE
[15,] editor character 1 vi
[16,] encoding character 1 native.enc
[17,] example.ask character 1 default
[18,] expressions integer 1 5000
[19,] help.ports integer 1 34298
[20,] help.search.types character 3 vignette demo help
[21,] help.try.all.packages logical 1 FALSE
[22,] help_type character 1 html
[23,] HTTPUserAgent character 1 R (2.14.1 x86_64-pc-linux-gnu x86_64 linux-gnu)
[24,] internet.info double 1 2
[25,] keep.source logical 1 TRUE
[26,] keep.source.pkgs logical 1 FALSE
[27,] locatorBell logical 1 TRUE
[28,] mailer character 1 mailto
[29,] max.print double 1 10000
[30,] menu.graphics logical 1 FALSE
[31,] na.action character 1 na.omit
[32,] OutDec character 1 .
[33,] pager character 1 /usr/lib64/R/bin/pager
[34,] papersize character 1 a4
[35,] pdfviewer character 1 /usr/bin/xdg-open
[36,] pkgType character 1 source
[37,] printcmd character 1 /usr/bin/lpr
[38,] prompt character 1 >
[39,] repos character 1 http://cran.univ-lyon1.fr/
[40,] rl_word_breaks character 1 \t\n"\\'`><=%;,|&{()}
[41,] scipen double 1 0
[42,] show.coef.Pvalues logical 1 TRUE
[43,] show.error.messages logical 1 TRUE
[44,] show.signif.stars logical 1 TRUE
[45,] str list 3 strict.width=no digits.d=3 vec.len=4
[46,] stringsAsFactors logical 1 TRUE
[47,] texi2dvi character 1 /usr/bin/texi2dvi
[48,] timeout double 1 60
[49,] ts.eps double 1 1e-05
[50,] ts.S.compat logical 1 FALSE
[51,] unzip character 1 /usr/bin/unzip
[52,] useFancyQuotes logical 1 TRUE
[53,] verbose logical 1 FALSE
[54,] warn double 1 0
[55,] warning.length integer 1 1000
[56,] width integer 1 150
Toutes les options par type puis par ordre alphabétique
=======================================================
Option Type Longueur Valeur
[1,] bitmapType character 1 cairo
[2,] continue character 1 +
[3,] contrasts character 2 contr.treatment contr.poly
[4,] defaultPackages character 6 datasets utils grDevices graphics stats methods
[5,] demo.ask character 1 default
[6,] device character 1 RStudioGD
[7,] dvipscmd character 1 dvips
[8,] editor character 1 vi
[9,] encoding character 1 native.enc
[10,] example.ask character 1 default
[11,] help.search.types character 3 vignette demo help
[12,] help_type character 1 html
[13,] HTTPUserAgent character 1 R (2.14.1 x86_64-pc-linux-gnu x86_64 linux-gnu)
[14,] mailer character 1 mailto
[15,] na.action character 1 na.omit
[16,] OutDec character 1 .
[17,] pager character 1 /usr/lib64/R/bin/pager
[18,] papersize character 1 a4
[19,] pdfviewer character 1 /usr/bin/xdg-open
[20,] pkgType character 1 source
[21,] printcmd character 1 /usr/bin/lpr
[22,] prompt character 1 >
[23,] repos character 1 http://cran.univ-lyon1.fr/
[24,] rl_word_breaks character 1 \t\n"\\'`><=%;,|&{()}
[25,] texi2dvi character 1 /usr/bin/texi2dvi
[26,] unzip character 1 /usr/bin/unzip
[27,] browser closure 1 <<function...>>
[28,] internet.info double 1 2
[29,] max.print double 1 10000
[30,] scipen double 1 0
[31,] timeout double 1 60
[32,] ts.eps double 1 1e-05
[33,] warn double 1 0
[34,] digits integer 1 7
[35,] expressions integer 1 5000
[36,] help.ports integer 1 34298
[37,] warning.length integer 1 1000
[38,] width integer 1 150
[39,] str list 3 strict.width=no digits.d=3 vec.len=4
[40,] add.smooth logical 1 TRUE
[41,] browserNLdisabled logical 1 FALSE
[42,] check.bounds logical 1 FALSE
[43,] device.ask.default logical 1 FALSE
[44,] echo logical 1 TRUE
[45,] help.try.all.packages logical 1 FALSE
[46,] keep.source logical 1 TRUE
[47,] keep.source.pkgs logical 1 FALSE
[48,] locatorBell logical 1 TRUE
[49,] menu.graphics logical 1 FALSE
[50,] show.coef.Pvalues logical 1 TRUE
[51,] show.error.messages logical 1 TRUE
[52,] show.signif.stars logical 1 TRUE
[53,] stringsAsFactors logical 1 TRUE
[54,] ts.S.compat logical 1 FALSE
[55,] useFancyQuotes logical 1 TRUE
[56,] verbose logical 1 FALSE
Code-source php de cette page. Retour à la page principale du cours.
|
Retour à la page principale de
(gH)