Técnicas Informáticas para la Estadística

• https://www.kernel.org/

• libC
• coreutils

• documentación

• x.org, en Freedesktop
• wayland sustituye a X en las últimas versiones de Ubuntu

• https://www.gnome.org/

La raíz del árbol de directorios. En Windows sería similar a «C:». Sin embargo, en Windows los dispositivos nuevos aparecen fuera (por ejemplo, una memoria USB puede aparecer como dispositivo «H:») mientras que en Ubuntu todos los dispositivos se montan en el mismo árbol de directorios (por ejemplo, en /media/nombreusuario/MemoriaUSB).

En principio, cada directorio en /home se corresponde con una cuenta de usario. Por ejemplo, en la sala B08 de la Facultad de Ciencias de la Universidad Oviedo cada ordenador tiene /home/administrador y /home/alumno. Para los usuarios que acceder con su cuenta centralizada universitaria la carpeta personal se crea en /home/likewise-open/IDENT/.

Directorio de ficheros temporales. Todo lo que no se quiera conservar, se puede crear o mover ahí.

Directorio de contenidos variables del sistema. En concreto, en /var/log/ se almacenan los ficheros de registro de los diferentes servicios del sistema operativo. Por ejemplo, en /var/log/messages o /var/log/syslog.

Aquí aparecen los ficheros de los disposivos externos, como un DVD o una memoria USB.

AVISO: Desde octubre de 2022, si se quiere acceder a un servidor de la universidad desde fuera de su red es necesario usar autenticación de doble factor. Una posibilidad es, antes de usar SSH o PuTTY, conectar con la red privada de la uni mediante algún cliente como Forticlient VPN siguiendo por ejemplo estas instrucciones. En 2023, es posible que Forticlient ya no funcione y que haya que usar GlobalProtect (consultar en la intranet de uniovi el software corporativo de acceso remoto o gpclient con openconnect).

Para acceder con terminal a otra máquina:

ssh alumno@zadeh.ciencias.uniovi.es

Para acceder desde Windows o ReactOS, puedes usar la "línea de comandos" que se obtiene

• pulsando la tecla windows junto con la R (erre) y luego
• tecleando cmd y pulsando Intro

o bien mediante el programa PuTTY indicando el nombre de la máquina (p.ej. zadeh.ciencias.uniovi.es) o su dirección IP (p.ej. 156.35.96.173) y la puerta o puerto de acceso (22, por omisión y en general).

Para copiar una carpeta local a la máquina remota:

scp -rp carpetaLocal alumno@zadeh.ciencias.uniovi.es:~

o bien:

scp -rp carpetaLocal alumno@zadeh.ciencias.uniovi.es:~/carpetaRemota

Para copiar una carpeta remota a la máquina local:

scp -rp alumno@zadeh.ciencias.uniovi.es:~/carpetaRemota .

Para copiar de manera gráfica, puedes usar

• el navegador de ficheros (p.ej. Nautilus del Gnome en Ubuntu)
• Filezilla
• WinSCP en Windows

Crearemos una imagen pequeña a partir de una grande, primero desde la interfaz gráfica de GIMP y luego usando el comando «convert».

1. Con GIMP.
   1. Consigue una imagen. Por ejemplo, descarga una (a la carpeta Descargas) con Firefox usando este enlace: imagen
   2. Abre el programa GIMP (o Krita o MyPaint…).
   3. En el menú Imagen de GIMP, elige la opción Escalar imagen. Adapta la imagen para que tenga 300 pixeles de anchura. Expórtala con un nombre distinto (por ejemplo, diagramas-gimp.png) y sal de GIMP.
   4. Comprueba las diferencias en tamaño de fichero respecto a la imagen original.

2. Con ImageMagick.

   Abre un terminal y escribe

   ls
   cd Descargas
   convert -resize 300 diagramas.png diagramas-convert.png
   

   Compara el nuevo fichero creado con los que ya existían.

   Puedes salir del terminal pinchando en el aspa del marco de la ventana, o escribiendo exit o pulsando C-d (es decir, Crtl+D, simultáneamente las teclas Ctrl y D).

Otro ejemplo con R e Imagemagick:

setwd("/tmp") # trabajaremos en el directorio temporal
png()         # crearemos >600 ficheros de imágenes
for (angulo in seq(0,2*pi,0.01)) # en radianes
    plot (cos(angulo), sin(angulo), # recorremos circunferencia
          xlim=c(-1,1), ylim=c(-1,1)) # para que coincidan ejes
dev.off()     # cerramos el desvío de gráficos a ficheros
## pueden pegarse las imágenes con:
## $ cd tmp
## $ convert -delay 1 -loop 0 Rplot*.png anime.gif

1. Crea una carpeta con el nombre textos dentro de Descargas.
2. Descarga¹ dentro de textos los ficheros disponibles en http://bellman.ciencias.uniovi.es/~carleos/master/manadine/curso1/TIplE/ejercicios/datos/textos
3. Abre un terminal.

Todo lo que se escribe a continuación de una almohadilla² «#» se considera un comentario y no se ejecuta:

# esto es un comentario

man ls         # página de manual sobre ls; q para salir;
apropos rename # comandos cuya descripción contiene rename

• Algunos comandos que usaremos (como cd) no contienen ayuda propia. Están documentados en el manual del intérprete de comandos (man bash).
• Todo paquete de Ubuntu tiene documentación guardada en el directorio /usr/share/doc/
• Buscando por internet, hay foros como Stackoverflow o Askubuntu cuyos usuarios resuelven problemas concretos.

Otros manuales están disponibles con la orden info. En concreto, muchas de las órdenes que veremos están disponibles en coreutils:

info coreutils        # q para salir;

Los comandos tienen un comportamiento por omisión, que puede ser modificado mediante opciones (que suelen comenzar con un guion «-»):

uname      # por omisión da el nombre del núcleo del sistema operativo
uname -a   # «a» significa «all»; da más información;

La carpeta personal se representa abreviadamente por una virgulilla: ~

La carpeta personal de otro usuario se representa abreviadamente por una virgulilla seguida por el nombre de usuario; por ejemplo: ~carleos

Los directorios se separante mediante barras: /

La ruta desde la raíz al directorio actual puede conocerse ejecutando

pwd

Su nombre significa «print working directory».

(En R, la instrucción equivalente sería getwd()).

ls /var/log/alternatives*gz       # * sustituye múltiples caracteres
ls /var/log/alternatives.log.?.gz # ? sustituye un único carácter
cd /var/log
ls alternatives.log.[467].gz      # 4 ó 6 ó 7
ls alternatives.log.[4-7].gz      # rango de 4 a 7
ls alternatives.log.[^4-7].gz     # fuera del rango de 4 a 7
ls alternatives.log.{1,2}.gz      # .log.1 y .log.2.gz

La salida de un comando puede guardarse en un fichero mediante un ángulo «mayor que»: >

ls /usr/share/doc >  /tmp/lista1.txt                      # redirige stdout
cat ~/Descargas/textos/texto* > ~/Descargas/textos-juntos # pega varios ficheros

La salida de un proceso puede aprovecharse «al vuelo» mediante un tubo «|»:

ls -lR / | head -n 20 # para ver los 20 primeros renglones
ls | wc -l            # cuántos ficheros no visibles hay en el directorio actual
head -n 1 /etc/passwd | tr ' ' '_' | tr ':' ' ' | wc -w # contar campos
tail /etc/passwd | cut -d ':' -f 1,5,6 # tres campos de los últimos 10 renglones

El programa «tee» (T) permite redirigir la salida a un fichero al tiempo que se aprovecha en un tubo:

ls -lR / | tee /tmp/todos-los-ficheros.txt | less

Si queremos quedarnos sólo con algunos de los renglones de la salida de un comando, podemos usar el comando grep. Por ejemplo, para quedarnos con los nombres de los ficheros en /var/log cuyos nombres contienen la secuencia natives:

ls /var/log | grep natives

Ahora, los que acaben en gz:

ls /var/log | grep gz$

Ahora, los que empiecen por kern:

ls /var/log | grep ^kern

Igualmente pueden filtrarse los renglones de un fichero. Las dos órdenes siguientes son equivalentes:

grep GNU /usr/share/common-licenses/GPL
cat /usr/share/common-licenses/GPL | grep GNU

Para comprimir un fichero se usa gzip:

gzip fichero.txt

Desaparece fichero.txt y aparece el fichero fichero.txt.gz.

Para descomprimir un fichero se usa gunzip:

gunzip fichero.txt.gz

El fichero se convierte en fichero.txt.

También hay otros compresores y empacadores famosos (bzip2, 7zip, xz, unzip, unrar, tar…)

El comando locate busca los ficheros en un banco de datos que genera periódicamente el sistema. Por la tanto, puede que no encuentre ficheros de reciente creación. Para estos últimos hay que usar find.

locate alternatives                   # búsqueda rápida (aunque no actual del todo)
find /var/log -name '*alternatives*'  # buscar ficheros actualmente en un directorio
find /var/log -iname '*ALTERNATIVES*' # búsqueda sin diferenciar úsculas
find  ~ -mtime -3                     # buscar los modificados hace menos de tres días
find  ~ -mtime +3                     # buscar los modificados hace más de tres días
find  ~ -mtime  3                     # buscar los modificados hace tres días (entre 72h y 96h)

Para evitar muchos mensajes de que no hay permisos:

find / -name '*alternatives*' 2>/dev/null

Vamos a descargar ahora una serie de imágenes para reducirlas después todas ellas a 300 pixeles:

cd ~/Imágenes
wget -rl1 http://156.35.96.172/incubadora/edicion4/fotos/badajoz-asturianos/exposicion-equipo-Oviedo/
ls -R
cd 156.35.96.172/incubadora/edicion4/fotos/badajoz-asturianos/exposicion-equipo-Oviedo/
for i in *jpg; do convert -resize 300 $i $i-300.jpg; done

En el bucle for anterior, la cadena -300.jpg se añade al nombre del fichero original. No parece muy correcto que quede un nombre como imagen.jpg-300.jpg; lo normal es que tengamos un nombre como imagen-300.jpg. Para ello, podemos usar la orden basename, que permite eliminar la extensión del nombre de un fichero:

basename imagen.jpg .jpg    # devuelve la cadena «imagen»

Necesitamos saber cómo empotrar el resultado devuelto por una orden en otra. Para eso existe la construcción $(...). Veamos un ejemplo:

echo Hola, Mundo                  # «echo» escribe sus argumentos
expr 5 + 15                       # devuelve «20»
echo 5 + 15 = $(expr 5 + 15)      # devuelve «5 + 15 = 20»

Así, el bucle quedaría:

for i in *jpg; do convert -resize 300 $i $(basename $i .jpg)-300.jpg; done

Cuando los nombres de ficheros contienen espacios, se pueden usar comandos (find -print0, xargs -0) que separen las distintas caderas mediante un carácter especial (ASCII cero, NUL), pero nos va a ser mucho más cómodo realizar la tarea en R. Por ejemplo:

### consigue varias capturas de pantalla pulsando ImprPant
### se almacenan en ~/Imágenes
### crea las carpetas vacías ~/Imágenes/PNG y ~/Imágenes/JPG
### mete las capturas en ~/Imágenes/PNG
### convierte las capturas a ficheros JPEG dentro de ~/Imágenes/JNG

setwd ("/home/alumno/Imágenes")
f <- system ("ls PNG", intern=TRUE) # nombres de las imágenes
f <- gsub (".png", "", f, fixed=TRUE)
## instrucción de Bash:
## convert 'PNG/nombreimagen.png' 'JPG/nombreimagen.jpg'
for (nombreimagen in f)
    system (paste0 ("convert 'PNG/",
                    nombreimagen,
                    ".png' 'JPG/",
                    nombreimagen,
                    ".jpg'"))

El comando system requiere la construcción de una cadena (aquí mediante paste0) que se ejecutará en Bash. Puede ser más cómodo usar el comando alternativo system2 que permite enviar los argumentos separadamente, permitiendo proteger los nombres de ficheros aplicando shQuote. Por tanto, la orden siguiente

system ("touch '/tmp/fichero con nombre raro' /tmp/'y otro'")

equivale a

system2 ("touch", 
         sapply (c("/tmp/fichero con nombre raro", "/tmp/y otro"),
                 shQuote))

Vamos a explorar el contenido de un fichero PDF contenido en un servidor remoto. Primero revisaremos su contenido textual dentro del terminal puro:

ssh carleos@carleos2.epv.uniovi.es    # entramos en el servidor;
cp /home/manadine/dat/venkatraman.pdf ~ # copiamos el fichero a la carpeta personal;
cd                                    # cambiamos al directorio personal;
ls                                    # comprobamos que existe un fichero «venkatraman.pdf»;
pdftotext venkatraman.pdf             # genera «venkatraman.txt»;
less venkatraman.pdf                  # «q» para salir; «-S» si tu terminal no es suficientemente ancho;
pdftotext -layout venktraman.pdf      # genera un fichero de texto en dos columnas;
less -S venkatraman.pdf               # la opción «-S» equivale a pulsar «-S» una vez dentro;
exit                                  # terminamos la sesión remota

Ahora vamos a entrar en el servidor remoto, activando también un canal gráfico para poder ver el PDF en todo su esplendor:

ssh -Y carleos@carleos2.epv.uniovi.es    # la opción «-Y» habilita el canal gráfico
evince /tmp/ROK/venkatraman.pdf          # se abre una ventana para ver el PDF a distancia
exit                                     # salimos después de cerrar la ventana de «evince»

Por supuesto, en vez de visualizar el fichero en remoto podríamos copiarlo al ordenador local mediante una orden como

scp carleos@carleos2.epv.uniovi.es:/home/manadine/dat/venkatraman.pdf .

Para acceder remotamente desde un ordenador con Windows o ReactOS, puedes usar PuTTY. Si necesitas usar ventanas gráficas, puedes instalar Xming y activar "X11 Forwarding" en PuTTY. Otra posibilidad sería instalar en la máquina remota un servidor de escritorio remoto (VNC, Xrpd, X2go…).

Para copiar ficheros remotamente desde un ordenador con Windows o ReactOS, puedes usar WinSCP o Filezilla.

• Descargar el último R desde https://cran.r-project.org/bin/windows/base
• Ejecutar el fichero .exe descargado (actualmente, versión 3.4.1).
• Pulsar Siguiente hasta el diálogo Opciones de configuración. Ahí elegir Sí y pulsar Siguiente.
• Elegir en Modo de display la opción SDI - ventanas separadas.
• Mantener las opciones por omisión en el resto de diálogos, hasta Instalando.
• Ejecutar R pinchando el icono R x64 3.4.1.

• Ejecutar en la consola de R la orden

  install.packages(c("actuar","Rcmdr","boot","bootstrap","evd","extRemes","pwr","mcmc","survey","sampling","SDaA","pps",
                     "pwr","TeachingSampling","TeachingDemos","RcmdrPlugin.TeachingDemos","optrees","RWeka","genalg","GA","ChainLadder"))
  

• Ojo, en algunos ordenadores con Windows 10 hemos tenido que desinstalar R, eliminar la carpeta C:/Usuarios/nombreordenador/Documentos/R, reinstalar R desde cero, ejecutarlo como administrador y ejecutar:

  install.packages(c("actuar","Rcmdr","boot","bootstrap","evd","extRemes","pwr","mcmc","survey","sampling","SDaA","pps",
                     "pwr","TeachingSampling","TeachingDemos","RcmdrPlugin.TeachingDemos","optrees","RWeka","genalg","GA","ChainLadder",
                     "Formula","sandwich","ggplot2","acepack","base64enc","latticeExtra","gridExtra","checkmate","data.table","e1071","readxl","haven","nortest","sem","rmarkdown","multcomp","lmtest","leaps","aplpack"),lib=.Library)
  

• Ejecutar en la consola de R la orden

  library(Rcmdr)
  

• Cuando pregunte si instalar paquetes adicionales, pulsar Sí.
• Es posible que pregunte en algún momento si instalar paquetes en un directorio alternativo. Aceptar el que da por omisión.

Ojo a la diferencia entre paquetes APT (de Debian/Ubuntu, programas empaquetados para ser fácilmente instalables en Debian/Ubuntu) y paquetes de R (bibliotecas o extensiones de R). Hay paquetes de R (por ejemplo, Rcmdr) que tienen su propio paquete de Ubuntu (siguiendo el ejemplo, r-cran-rcmdr), pero otros muchos no.

Instalable desde el paquete de Ubuntu rkward

Tiene un buen editor de datos en forma de cuadrícula o rejilla de hoja de cálculo.

En los menús sólo implementa recodificación de variables cualitativas. Las trasformaciones más complejas deben hacerse desde la consola.

$ cd ~/directorio/de/trabajo
$ R
> q()                                # para salir
Save workspace image? [y/n/c]: n

Si se pulsa y para salir, entonces aparecen los ficheros .Rhistory y .RData. El primero contiene los comandos ejecutados en la sesión y el segundo alberga los objetos creados. Ejemplo:

$ R
> variable = "texto de ejemplo"
> q()
Save workspace image? [y/n/c]: y
$ R
> variable                           # comprobamos que el valor se había guardado

Si pulsamos la flecha hacia arriba (ó Ctrl-P) entonces recuperamos los comandos de la sesión anterior.

Esto es útil si arrancamos R en directorios distintos para sesiones de trabajo que tengan que ver con cosas distintas.

Para editar un programa de R dentro de la sesión, puede usarse:

$ R
> system ("gedit miprograma.R&")   # el símbolo & implica ejecución en segundo plano (asíncrona)

1. Descargar el fichero http://rstudio.com -> Desktop -> Download -> ZIP/Tarballs -> Debian/Ubuntu 64-bit

   Se puede comprobar la integridad del fichero usando el comando md5sum.

2. Abrir con: Gestor de archivadores
3. Extraer en (por ejemplo) Escritorio
4. Entrar en la carpeta =~/Escritorio/rstudio-0.99.903/bin
5. Botón derecho sobre rstudio, elegir «Crear un enlace»
6. Mover el nuevo Enlace hacia rstudio al Escritorio
7. Botón derecho sobre Enlace hacia rstudio, elegir «Propiedades», pinchar en el icono y elegir ~/Escritorio/rstudio-0.99.903/rstudio.png

Instalable como paquete de Ubuntu llamado r-cran-rcmdr o como paquete de R llamado Rcmdr.

Una vez instalado, se puede buscar directamente en el buscador de aplicaciones de Ubuntu.

Si se está ejecutando R en terminal o en Rkward o en Rstudio, se puede arrancar Rcmdr mediante:

library(Rcmdr)

Si ya se ha ejecutado esa orden y, habiendo salido de Rcmdr, se quiere volver a entrar sin salir de R, ejecútese

Commander()

Si has usado Rcmdr desde terminal, al salir de Rcmdr puede haberse corrompido el terminal. Escribiendo reset vuelve a la normalidad.

Probablemente el mejor entorno integrado para programar en R, sobre todo si prefieres moverte con el teclado en vez de con el ratón.

Emacs también es un buen entorno para programar en Octave, Maxima, \(\LaTeX\), etc.

En Ubuntu, ESS se encuentra disponible en el paquete ess.

Para encontrar ayuda sobre un comando de R, por ejemplo rep, puedes usar

?rep

Para algunos comandos con nombres especiales, hay que usar comillas; por ejemplo,

?"["
?"if"
help("if")

Si sólo conocemos parte del nombre del comando (p.ej. norm), usamos

apropos("norm")

Si queremos encontrar información relacionada con un concepto, podemos usar:

??variance
help.search("variance")

• si se escribe el carácter almohadilla «#» todo lo que queda a su derecha en el mismo renglón no se evalúa

• se usa para introducir comentarios en código fuente de R

  help("if") # sirve para buscar la ayuda asociada a la orden "if"
  

• otro uso frecuente es para desactivar parte de un programa

  # desactivo temporalmente lo relativo a la variable "z"
  x <- 10
  y <- 15
  # z <- 34
  x + y # + z
  

• todo objeto del lenguaje R puede almacenarse en una variable

  radio <- 10          # asignamos el valor '10' a la variable 'radio'
  radio                # para comprobar el valor almacenado
  radio = 20           # otra forma de asignar
  30 -> radio          # otra forma de asignar
  assign ("radio", 40) # otra forma de asignar 
  

  • el operador habitualmente recomendado para asignar en programas es <-
  • el operador «=» se usa también para asignar valores a argumentos de funciones, por lo que su uso puede resultar ambiguo
  • la función assign se usa sobre todo si el nombre de la variable se determina durante la ejecución del programa

• para conocer qué variables hay definidas en cierto momento

  ls()
  

• para borrar la definición de una variable se puede usar alguna de estas dos formas

  rm (radio)
  rm (list = "radio")
  

• si se quieren eliminar todas las variables definidas hasta el momento

  rm (list = ls())
  

• en principio, los nombres de variables no pueden contener ciertos caracteres, por ejemplo espacios; no es recomendable, pero en caso de necesidad podrían incluirse así:

  > assign("radio exterior", 50)
  > get("radio exterior")
  [1] 50
  

• ese get permite construir el nombre de la variable al vuelo:

  > radio1 <- 15; radio2 <- 20; radio3 <- 50
  > for (i in 1:3) cat("El radio número", i, "vale", get(paste0("radio",i)), "\n")
  El radio número 1 vale 15 
  El radio número 2 vale 20 
  El radio número 3 vale 50
  
  > generar_muestra <- function (distri, n=1e6) get(paste0("r",distri))(n)
  > summary (generar_muestra("unif"))
     Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
   0.0000  0.2506  0.5004  0.5003  0.7504  1.0000 
  > summary (generar_muestra("norm"))
       Min.   1st Qu.    Median      Mean   3rd Qu.      Max. 
  -5.454608 -0.673935  0.000999  0.000654  0.673568  4.996585 
  

Consultar el capítulo 11 de Una introducción a R.

• modelo lineal

  y ~ x
  

• modelo cuadrático

  y ~ x + I(x^2)
  

• para muestrear se usa sample

  sample (6)                    # permuta números del 1 al 6
  sample (letters)              # permuta un vector arbitrario
  sample (6, 1)                 # 1 tirada de dado hexagonal
  sample (letters, 3)           # tres letras que no se repiten
  sample (6, 10, replace=TRUE)  # 10 tiradas de dado 
  sample (c("M","H"), 100, 
          replace=TRUE, prob=c(.49,.51)) # no equiprobables
  

• para muestrear de una variable aleatoria, se usan funciones cuyos nombres comienzan por r: rbinom, rexp, rpois, rnorm, runif…

  hist (rnorm(10000), breaks=100)
  hist (runif(10000), breaks=100)
  

  (sustituyendo la r inicial por d tendríamos la densidad; por p, tendríamos la función de distribución; por q, la función cuantil)

• condicionales Generemos un vector de temperaturas:

  t <- runif (15, 10, 40)
  

  Para combinar comparaciones vectorialmente, usamos ifelse y un operador «lanzado» («&» = «y»; «|» = «ó»):

  ifelse (t>20 & t<30, "agradable", "desagradable")
  

  Para combinar comparaciones de forma que esperamos un único booleano, usamos operadores «cortocircuito» («&&» = «y»; «||» = «ó»):

  n=10; if (is.numeric(n) && length(n)==1 && n>0) sqrt(n) else "no puedo"
  

• bloques de instrucciones mediante llaves «{}»; se usan en contextos donde tiene que ir más de una instrucción:

  if (n > 5) {print("demasiado grande"); n<-5} else {print("demasiado pequeño"); n<-n+1}
  

  El valor devuelto por un bloque es el valor devuelto por su última instrucción.

• bucles

  for (i in 1:10) cat ("El cuadrado de", i, "es", i^2, "\n")
  

  Detrás de «in» puede ir cualquier vector o lista; por ejemplo

  for (i in letters) {cat (i); cat (toupper (i)); cat ("-")}; cat ("\n")
  for (i in iris) print (summary (i))
  

• bucles con acumulador

  Se define una variable (acumulador) antes del bucle para que recoja los resultados:

  suma <- 0; for (i in 1:10) suma <- suma+i; suma                       # equivale a sum(1:10) -> suma
  producto <- 1; for (i in 1:10) producto <- producto*i; producto       # prod(1:10); factorial(10) -> producto
  bector <- c(); for (i in 1:10) bector <- c(bector,i^2); bector        # (1:10) ^ 2 -> bector
  lista <- list(); for (i in 1:10) lista <- c(lista,list(1:i)); lista   # sapply (1:10, function (i) 1:i) -> lista
  

• con nombre

  f <- function(x) x^2
  f(15)
  

• anónimas (útiles para definiciones al vuelo, como se ve en la sección siguiente)

  (function(x) x^2) (15)
  

• pueden tener varios argumentos

  var.ponderada <- function (x, pesos)     # varianza ponderada
  {  mp <- weighted.mean (x, pesos)        # media ponderada
     weighted.mean ((x - mp) ^ 2, pesos) }
  

• cada argumento puede tener un valor por omisión

  var.ponderada <- function (x, pesos = rep(1,length(x)))
  {  mp <- weighted.mean (x, pesos)
     weighted.mean ((x - mp) ^ 2, pesos) }
  

• pueden pasar sus argumentos a otras funciones mediante «…»

  var.ponderada <- function (x, pesos, ...)
  {  mp <- weighted.mean (x, pesos, ...)
     weighted.mean ((x - mp) ^ 2, pesos, ...) }
  

  por ejemplo:

  muestra <- c (1, 20, NA, 5); pesos <- c (1,2,3,4)
  weighted.mean (muestra, pesos); 
  weighted.mean (muestra, pesos, na.rm=TRUE)
  var.ponderada (muestra, pesos)                  # produce NA
  var.ponderada (muestra, pesos, na.rm=TRUE)      # pasa «na.rm=TRUE» a weighted.mean
  

• recursivas: una función puede llamarse a sí misma

  mifactorial <- function(n) if (n==0) 1 else n*mifactorial(n-1)
  

  otro ejemplo:

  nombres <- c("Señor don Manuel Montenegro", "Asun Lubiano", "Doña Antonia Salas",
               "Don Norberto Corral", "Carlos Carleos")
  títulos <- c("don", "doña", "señor", "señora")
  
  ## dado un vector de nombres, obtener el nombre de pila (una palabra) de cada uno
  nombre.de.pila <- function(cadena)
      nombre.de.pila_vector (strsplit (cadena, " ") [[1]]) # convierte "cadena" en vector de palabras
  
  nombre.de.pila_vector <- function(v)    # v = vector de cadenas
  {
      palabra1 <- v[1]
      if (tolower(palabra1) %in% títulos) # tolower = convierte a minúsculas
        nombre.de.pila_vector(v[-1])      # llamada recursiva
      else palabra1
  }
  
  for (nombre in nombres) print (nombre.de.pila (nombre))
  

• las definiciones de variables pueden no estar disponibles en la instalación básica de R, pero sí en bibliotecas o paquetes

• para ver qué paquetes están instalados:

  installed.packages ()
  

• para usar una función definida en un paquete:

  e1071::skewness (rexp (10))
  

  o bien

  library (e1071)             # o library("e1071")
  skewness (rexp (10))
  

• para instalar un paquete no instalado:

  install.packages ("primes")
  primes::is_prime (101)      # sólo funciona si "primes" está instalado
  

• para actualizar todos los paquetes instalados:

  update.packages (ask = FALSE)
  

• sobre secuencias (vectores o listas)

  • sapply (con s de simple) se usa para generar un vector (o una matriz, si el resultado de la función aplicada es vectorial)

    sapply (1:10, sqrt)                       # aplicar una función con nombre
    sapply (1:10, function(x) x**2)           # aplicar una función anónima
    sapply (1:10, function(x) c(x^2,x^3))     # el resultado es una matriz
    

  • sapply conserva etiquetas si se aplica a un vector de cadenas

    sapply(3:5, sqrt)                         # sin etiquetas
    sapply(c("uno","dos","tres"), nchar)      # con etiquetas
    structure (sapply(3:5, sqrt), names=3:5)  # forzar etiquetas
    

  • lapply (con l de lista) devuelve una lista

    lapply (1:10, function(i) list (i, list(letters[i],month.name[i])))
    

    aunque si se quieren conservar etiquetas mejor usar sapply o (si hace falta) sapply(..., simplify=FALSE)

    lapply (c ("uno", "dos", "tres"), nchar)
    sapply (c ("uno", "dos", "tres"), nchar)
    sapply (c ("uno", "dos", "tres"), nchar, simplify=FALSE)
    

• apply se usa para aplicar una función a filas o columnas de una matriz…

  m <- matrix (1:12, 3)
  apply (m, 1, sum)                 # aplicar por filas
  apply (m, 2, sum)                 # aplicar por columnas
  

  …o a un dataframe; en este caso, téngase en cuentra que se trasforma en matriz (homogénea) antes de aplicarse la función, por lo que (por ejemplo) si el dataframe contiene un factor todos los datos aparecen como cadenas:

  ## queremos trasformar todos los 4 de ChickWeight a NA
  ChickWeight
  cuatroNA <- function (x) {x[x==4] <- NA; x}
  cuatroNA (1:10)                                       # funciona
  cuatroNA (as.character (1:10))                        # funciona
  cuatroNA (factor (1:10))                              # funciona
  summary (apply (ChickWeight, 2, cuatroNA))            # apply no funciona (trasforma todo a factores)
  summary (data.frame (lapply (ChickWeight, cuatroNA))) # lapply sí funciona
  

  es decir, cuando queremos aplicar una función a cada variable de un dataframe,

  • es mejor considerar el dataframe como lista y usar lapply
  • que considerar el dataframe como matriz y usar apply

  otro ejemplo usando la función identity; identity(x) devuelve x

  mtcars
  apply(mtcars, 1, identity) # queda traspuesta
  apply(mtcars, 2, identity)
  identical(mtcars, data.frame (apply (mtcars, 2, identity))) # TRUE
  m    <- mtcars
  m$am <- factor(m$am)
  apply(m, 1, identity) # genera matrices de cadenas
  apply(m, 2, identity) # idem
  identical(m, data.frame (apply (m, 2, identity))) # FALSE
  

• para aplicar por grupos:

  prod <- 1:20; sexo <- rep(c("M","H"),each=10)
  tapply (prod, sexo, mean)           # por niveles de "sexo"
  by (prod, sexo, mean)               # ídem
  

• la más general (mapeo)

  mapply (rep, 1:4, 4:1)              # aplica funciones con varios argumentos
  

• un comando muy habitual en simulaciones:

  replicate (10000, {m <- rnorm(5); mean(m)})
  

  Funciona parecido a

  sapply (1:10000, function (i) {m <- rnorm(5); mean(m)})
  

  donde la variable i es sintácticamente necesaria pero su valor no se usa.

En general, nos interesará el indicado como «elapsed».

Para manejar cadenas de texto.

Las expresiones regulares interpretan algunos caracteres de forma especial.

• ^ = comienzo de cadena
• $ = fin de cadena
• [ ] = grupo de caracteres
• . = cualquier carácter
• * = cero o más repeticiones
• + = una o más repeticiones
• \ = quita el comportamiento especial a un carácter

Hay más referencias en la wikipedia.

• la instalación básica de R contiene dos sistemas de objetos
  • el llamado S3, que comentaremos en esta sección
  • el llamado S4, un sistema más formal pero no tan extendido como S3; no lo detallaremos
• características de un sistema orientado a objetos

  • polimorfismo: una función se comporta de manera distinta en función de su argumento

    summary (mtcars $ am)              # el argumento es un vector numérico => media y 5 cuartiles
    summary (factor (mtcars $ am))     # el argumento es un factor => tabla de frecuencias absolutas
    

  • clase: el tipo de objeto

    class (mtcars $ am)              # el argumento es un vector numérico
    class (factor (mtcars $ am))     # el argumento es un factor
    

  • función genérica: una función que acepta argumentos de distintas clases y se comporta de forma distinta según la clase; por ejemplo, summary

  • método: implementación de una función genérica para cierta clase de argumentos

    methods (summary)                  # qué metodos hay definidos para "summary"
    summary.factor                     # implementación para factores
    summary.default                    # implementación por omisión, p.ej. para vectores numéricos
    summary.lm                         # implementación para modelos lineales
    summary.ecdf                       # error porque está indicado con * al ejecutar "methods(summary)"
    getAnywhere (summary.ecdf)         # forzamos la obtención del código fuente de dicho método
    

• objetos S3 en R

  • para estudiar el tipo de un objeto, se usan class y mode

    m <- matrix (1:12, 3)
    class (m)                            # matrix
    mode  (m)                            # integer
    class (mtcars)                       # data.frame
    mode  (mtcars)                       # list
    class (1:5)                          # integer
    class (sum)                          # function
    class (function (x) x^2)             # function
    class (by(mtcars$mpg,mtcars$am,mean) # by
    

  • a un objeto de R se le pueden asociar atributos

    ob <- 1:5
    attributes(ob)                       # NULL
    attr(ob,"creador") <- "carlos"  
    ob
    attributes(ob)
    attributes(ob)$creador
    100 * ob                             # el objeto sigue comportándose normalmente
    

  • si un objeto tiene un atributo llamado class entonces ése determina su clase

    efe <- factor (c ("a", "a", "b"))
    efe
    attributes (efe)                     # levels y class
    unclass (efe)                        # un vector numérico
    

    a veces puede interesar deshacerse de la clase

    resumen  <- with (mtcars, by (wt, list(AM=am,VS=vs), median))
    resumenA <- unclass (resumen)              # conseguimos una matriz
    attr(resumenA,"call") <- NULL              # eliminamos atributos sobrantes
    

  • podemos inventar nuevas clases y definir métodos para ellas

    efe <- rbinom (10, 5, 0.3)
    class(efe)  <- "cuandiscreta"           # cuantitativa discreta
    attributes(efe)                         # class
    print.cuandiscreta <- function (x)
        print (factor (x))                  # se muestran los niveles...
    
    efe                                     # aplica el me'todo "print"
    efe * 100                               # pero puede usarse numéricamente
    
    summary.cuandiscreta <- function (x)
    {
        cat ("Cuantitativamente:\n")
        print (summary (as.numeric (x)))
        cat ("Discretamente:\n")
        print (summary (factor (x)))
    }
    
    summary (efe)                           # me'todo "summary"
    

• ejercicios
  • modificar el método summary de cuandiscreta para que dé también porcentajes
  • crear un método de la función plot que sea adecuado para cuandiscreta

• "cómodos" para programar
  • con poco código fuente se hacen muchas cosas
• en general, poco eficientes
  • aunque para cosas concretas pueden usar bibliotecas escritas en lenguajes compilados

• más "incómodos": hay que escribir mucho código para hacer lo básico

• sintaxis "sencilla"

  • casi sin sintaxis

  (función arg1 arg2 ... argN)    # para todo
  (+ 3 5 6 (/ 9 2) (/ 5) (* 1 (- 1 2)))
  (+ 3 
     5 
     6 
     (/ 9 2) 
     (/ 5) 
     (* 1 
        (- 1 2)))
  (dolist (i lista) (print (elt lista i)))
  (if (< 0 x 20) 
      (print "dentro de límites")
      (print "fuera")
  

  • editores de texto permiten navegar el código fuente como un árbol
  • código fuente procesable fácilmente como datos
• permite generar código muy eficiente
• macros: permiten programar a muy alto nivel

• sintaxis de Matlab
• más cómodo que R para lo básico
  • menos paréntesis
  • menos llaves
• más incómodo para programas largos
  • sintaxis más irregular, menos predecible
• más lento que R

• sintaxis similar a Octave
• compilado: más rápido que R

• cálculo simbólico