# Instalaciones, si falla cargar las librerias
install.packages('stringi', dependencies = T, quiet = T)
install.packages("BiocManager", dependencies = T, quiet = T )
BiocManager::install("GEOquery", checkBuilt = T, ask = F )library(magrittr) # Operadores cañeria (pipes) %>%
library(stringi) # Generador de strings aletaoriosDefinimos un objeto que usaremos para los ejemplos con loops.
largo <- 60 # Filas en el objeto
# Relleno del objeto usando funciones r{base}
sample(letters, largo, replace = T) -> a # Relleno a
sample(1:10, largo, replace = T) -> b # Relleno b
# Usando funciones de Stringi
stri_rand_strings(largo,8, pattern = "[A-B0-9t-z]") -> my.rows
stri_rand_strings(2, # Dos strings
4, # De largo 4 caracteres
pattern = "[A-G]" # Con las letras ABCDEFG
) -> my.cols # Guardado en "my.cols"
# Guardando el objeto a usar
cbind(a,b) %>% # Une rellenos a y b
set_rownames(my.rows) %>% # Los nombres de las filas se llamaran como las my.rows
set_colnames(my.cols) -> my.mat # Los nombres de las columnas se llamaran como las my.cols## CCGF GEDG
## x02x6131 "a" "8"
## 2y053y19 "w" "7"
## vB3tx5y2 "c" "5"
## y869y2vz "k" "4"
## 55y90889 "s" "4"
## vt4599y4 "j" "7"
## t0Bww463 "z" "10"
## 14x33071 "t" "7"
## 4v00Bv46 "d" "1"
## A4x3t562 "y" "10"
## z5480y9u "w" "7"
## wvy0w2Bu "m" "8"
## y0wAAwtA "b" "7"
## 7y37ztzv "h" "10"
## tBxuuwzA "j" "9"
## yu859A1y "m" "1"
## 2x802z11 "p" "5"
## 9t17t287 "d" "1"
## Awwuzwv4 "v" "10"
## 5y7A0t75 "v" "1"
## B10v0431 "u" "2"
## x3Ay9868 "z" "6"
## yyzzt4yB "q" "8"
## x58v5y58 "g" "9"
## 1v26B59y "n" "4"
## 3xu3ty50 "y" "2"
## BA1u22xv "b" "3"
## 4y903250 "t" "8"
## xt4wu909 "o" "3"
## 0z61x73u "o" "2"
## 93Ay54uz "b" "8"
## xw0Avx7v "a" "6"
## v5113ut4 "h" "6"
## 9A74wy58 "a" "8"
## 84ztzBBt "a" "7"
## A7Awyz2y "c" "10"
## 1yAtBtuB "v" "8"
## 9176u6B5 "u" "6"
## 966BA7y3 "p" "8"
## B9u97u1y "m" "1"
## 48v7yxx7 "l" "2"
## 0B4xu3zA "a" "8"
## z87xuztv "d" "3"
## 632uA2Bv "u" "1"
## 4w940tz1 "d" "10"
## ywuu8uA0 "l" "3"
## 1A19tx5B "h" "6"
## x2ty4297 "k" "1"
## y5Ay15yw "a" "9"
## 12z744y9 "c" "4"
## 0v9839B7 "f" "6"
## 2575ty8A "n" "5"
## t0BuA4u7 "m" "9"
## z7237x65 "v" "1"
## B53xwwuB "h" "4"
## 3A29t24y "c" "6"
## 8t4x5vx1 "b" "10"
## 476y735t "b" "7"
## 2u29zyuw "t" "6"
## 0wAxA5w1 "e" "6"## x02x6131 2y053y19 vB3tx5y2 y869y2vz 55y90889 vt4599y4 t0Bww463 14x33071
## "a" "w" "c" "k" "s" "j" "z" "t"
## 4v00Bv46 A4x3t562 z5480y9u wvy0w2Bu y0wAAwtA 7y37ztzv tBxuuwzA yu859A1y
## "d" "y" "w" "m" "b" "h" "j" "m"
## 2x802z11 9t17t287 Awwuzwv4 5y7A0t75 B10v0431 x3Ay9868 yyzzt4yB x58v5y58
## "p" "d" "v" "v" "u" "z" "q" "g"
## 1v26B59y 3xu3ty50 BA1u22xv 4y903250 xt4wu909 0z61x73u 93Ay54uz xw0Avx7v
## "n" "y" "b" "t" "o" "o" "b" "a"
## v5113ut4 9A74wy58 84ztzBBt A7Awyz2y 1yAtBtuB 9176u6B5 966BA7y3 B9u97u1y
## "h" "a" "a" "c" "v" "u" "p" "m"
## 48v7yxx7 0B4xu3zA z87xuztv 632uA2Bv 4w940tz1 ywuu8uA0 1A19tx5B x2ty4297
## "l" "a" "d" "u" "d" "l" "h" "k"
## y5Ay15yw 12z744y9 0v9839B7 2575ty8A t0BuA4u7 z7237x65 B53xwwuB 3A29t24y
## "a" "c" "f" "n" "m" "v" "h" "c"
## 8t4x5vx1 476y735t 2u29zyuw 0wAxA5w1
## "b" "b" "t" "e" # Basicamente matriz[,"nombre de la primera columna"]
my.mat[2,] # Selecciona la segunda fila como muestra## CCGF GEDG
## "w" "7"my.mat[,2] %<>% as.numeric() # La segunda columna son numeros, pero lo considera string
# Entonces usamos as.numeric() para que lo interprete como numero
# %<>% es el operador de pipe bidireccional boomerangUtilizamos while en iteraciones dado que podemos programar un valor objetivo y hacer que el loop corra hasta que ese objetivo se cumpla. Por ejemplo, que la diferencia entre nuestro valor objetivo y el calculado en una simulación numerica sea menor a 0.1.
i = 0 # Definimos que nuestro indexador parta desde 0
while( i< nrow(my.mat) )
{
i = i + 1 # Avanza un punto del indice
paste0('looping at ',i) %>% # "Looping at i"
print # Imprime el string recien generado
}## [1] "looping at 1"
## [1] "looping at 2"
## [1] "looping at 3"
## [1] "looping at 4"
## [1] "looping at 5"
## [1] "looping at 6"
## [1] "looping at 7"
## [1] "looping at 8"
## [1] "looping at 9"
## [1] "looping at 10"
## [1] "looping at 11"
## [1] "looping at 12"
## [1] "looping at 13"
## [1] "looping at 14"
## [1] "looping at 15"
## [1] "looping at 16"
## [1] "looping at 17"
## [1] "looping at 18"
## [1] "looping at 19"
## [1] "looping at 20"
## [1] "looping at 21"
## [1] "looping at 22"
## [1] "looping at 23"
## [1] "looping at 24"
## [1] "looping at 25"
## [1] "looping at 26"
## [1] "looping at 27"
## [1] "looping at 28"
## [1] "looping at 29"
## [1] "looping at 30"
## [1] "looping at 31"
## [1] "looping at 32"
## [1] "looping at 33"
## [1] "looping at 34"
## [1] "looping at 35"
## [1] "looping at 36"
## [1] "looping at 37"
## [1] "looping at 38"
## [1] "looping at 39"
## [1] "looping at 40"
## [1] "looping at 41"
## [1] "looping at 42"
## [1] "looping at 43"
## [1] "looping at 44"
## [1] "looping at 45"
## [1] "looping at 46"
## [1] "looping at 47"
## [1] "looping at 48"
## [1] "looping at 49"
## [1] "looping at 50"
## [1] "looping at 51"
## [1] "looping at 52"
## [1] "looping at 53"
## [1] "looping at 54"
## [1] "looping at 55"
## [1] "looping at 56"
## [1] "looping at 57"
## [1] "looping at 58"
## [1] "looping at 59"
## [1] "looping at 60"Existen multiples funciones paste para concatenar strings, dependiendo de la situación
paste()incluye por defecto el separador, pero se puede especificar consep = ","u otro separador.paste0()no incluye separadores, por lo que puede ser más rapido para concatenación.
Es posible utilizar multiples operadores logicos en un loop while.
| Operador | Descripción |
|---|---|
a == b |
a es igual a b |
a != b |
a es distinto a b |
a > b |
a es mayor que b |
a < b |
a es menor que b |
a >= b |
a es mayor o igual que b |
a <= b |
a es menor o igual que b |
a & b |
a y b son VERDADEROS |
a | b |
a o b son VERDADEROS |
!a |
Negación de a |
for no incluye operadores logicos, solo un indice dentro de un vector.
for (i in 0:10) # i de index o iteration, en el vector (0:10)
{
print(i) # imprime i, que en este caso es (1,...,10)
Sys.sleep(0.1) # Pausa por 0.1 s para que sea visible el procesamiento
}## [1] 0
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10Con eso, podemos usar un vector no ordenado (4,3,0,2,1) para iterar en esa secuencia.
orden <- c("uno","dos","tres","cuatro")
desorden <- c(4,1,3,1,2)
for (i in desorden) # i de index o iteration, en el vector "desorden"
{
print(orden[i]) # imprime i, que en este caso es (desorden)
Sys.sleep(0.2) # Pausa por 0.2 ms para que sea visible la cosa
}## [1] "cuatro"
## [1] "uno"
## [1] "tres"
## [1] "uno"
## [1] "dos"Podemos usar los loops for para procesar un listado de archivos que tengamos en una carpeta de datos.
# Este ejemplo resulto más largo de lo que esperaba. --Manu
# Igual es verboso, por como lo escribi y para que se entienda
# Usa los archivos del .csv en el repo de la clase en Github
# No tiene contexto sin esos archivos, pero pueden ver el codifo
# Supongamos reportes del uso de servidores
data.dir = "./procesamiento-lotes/" # Los archivos están en un subdirectorio
reportes = c("instancias-09c.csv","instancias-09d.csv","instancias-10a.csv","instancias-10b.csv") # Y solo queremos importar algunos
library("readr") # Usamos esta para leer .csv
# Describimos que queremos en el resumen
n.instancias = c() # Instancias en la sesion
tiempo.cpu.p = c() # Tiempo promedio de uso de CPU
tiempo.cpu.t = c() # Tiempo total de uso de CPU
sub.utilizad = c() # Instancias con un uso < 20% maximo
i = 1 # Definimos un contador (R parte en 1, Otros en 0)
for (csv in reportes) # Empieza el loop
{
lote <- as.data.frame(read.csv2(paste0(data.dir, reportes[i]))) # Importa cada CSV
lote[[1]] <- NULL # Mata el index de las filas
# Guarda la información para resumes
n.instancias[i] = length(lote$ID)
tiempo.cpu.p[i] = mean(lote$CPUzeit)
tiempo.cpu.t[i] = sum(lote$CPUzeit)
sub.utilizad[i] = length((lote$CPUzeit)[lote$CPUzeit < .2*max(lote$CPUzeit)])
lote <- NULL # Limpiamos la RAM
i = i + 1 # Avanza el indice
}
# Reinicia el indice; y genera un reporte
i=1; resumen = data.frame(n.instancias, tiempo.cpu.p, tiempo.cpu.t, sub.utilizad)En el ejemplo sabemos el nombre de los archivos, pero podemos usar list.files() y sus parametros
list.files(getwd()) archivos en el directorio de trabajolist.files(getwd(), recursive = TRUE) directorio de trabajo y subdirectorios. Incluye el nombre del subdirectorio en la salida.list.files(getwd(), recursive = TRUE, pattern = <regex>) incluye una expresión regular para limitar la busqueda. Por ejemplo pattern = "*.csv$" lista todos los terminados en .csv# Lista todos los archivos .csv a un vector
# con forma subdirectorio/archivo.csv
v <- list.files(getwd(),
recursive = TRUE,
pattern = "*.csv$")Se puede eliminar el nombre del subdirectorio del listado utilizando funciones como str_replace() y regex. ## Barras de progreso
Para lotes grandes resulta util tener una barra de progreso, que indique el el sistema esta funcionando hacia la consola. Podemos usar el mismo indice i o poner condicionals para el avance de la barra, como pasar ciertas pruebas tipo if(...){TRUE}
##
|
| | 0%for(i in 1:nrow(my.mat)) # Desde 1 al largo de las filas en my.mat (60)
{
setTxtProgressBar(pb, i) # Imprime la barra de progreso
Sys.sleep(.1) # Espera 0.1 segundos
if (i == nrow(my.mat)) # Correr cuando este en la ultima iteracion
{
print('OK!')
}
}##
|
|= | 2%
|
|== | 3%
|
|==== | 5%
|
|===== | 7%
|
|====== | 8%
|
|======= | 10%
|
|======== | 12%
|
|========= | 13%
|
|========== | 15%
|
|============ | 17%
|
|============= | 18%
|
|============== | 20%
|
|=============== | 22%
|
|================ | 23%
|
|================== | 25%
|
|=================== | 27%
|
|==================== | 28%
|
|===================== | 30%
|
|====================== | 32%
|
|======================= | 33%
|
|======================== | 35%
|
|========================== | 37%
|
|=========================== | 38%
|
|============================ | 40%
|
|============================= | 42%
|
|============================== | 43%
|
|================================ | 45%
|
|================================= | 47%
|
|================================== | 48%
|
|=================================== | 50%
|
|==================================== | 52%
|
|===================================== | 53%
|
|====================================== | 55%
|
|======================================== | 57%
|
|========================================= | 58%
|
|========================================== | 60%
|
|=========================================== | 62%
|
|============================================ | 63%
|
|============================================== | 65%
|
|=============================================== | 67%
|
|================================================ | 68%
|
|================================================= | 70%
|
|================================================== | 72%
|
|=================================================== | 73%
|
|==================================================== | 75%
|
|====================================================== | 77%
|
|======================================================= | 78%
|
|======================================================== | 80%
|
|========================================================= | 82%
|
|========================================================== | 83%
|
|============================================================ | 85%
|
|============================================================= | 87%
|
|============================================================== | 88%
|
|=============================================================== | 90%
|
|================================================================ | 92%
|
|================================================================= | 93%
|
|================================================================== | 95%
|
|==================================================================== | 97%
|
|===================================================================== | 98%
|
|======================================================================| 100%[1] "OK!"##
|
| | 0%while(i < nrow(my.mat)) # Operador logico TRUE si i < filas en my.mat (60)
{
i = i +1
setTxtProgressBar(pb, i) # Imprime la barra de progreso
Sys.sleep(.1) # Espera 0.1 segundos
}##
|
|= | 2%
|
|== | 3%
|
|==== | 5%
|
|===== | 7%
|
|====== | 8%
|
|======= | 10%
|
|======== | 12%
|
|========= | 13%
|
|========== | 15%
|
|============ | 17%
|
|============= | 18%
|
|============== | 20%
|
|=============== | 22%
|
|================ | 23%
|
|================== | 25%
|
|=================== | 27%
|
|==================== | 28%
|
|===================== | 30%
|
|====================== | 32%
|
|======================= | 33%
|
|======================== | 35%
|
|========================== | 37%
|
|=========================== | 38%
|
|============================ | 40%
|
|============================= | 42%
|
|============================== | 43%
|
|================================ | 45%
|
|================================= | 47%
|
|================================== | 48%
|
|=================================== | 50%
|
|==================================== | 52%
|
|===================================== | 53%
|
|====================================== | 55%
|
|======================================== | 57%
|
|========================================= | 58%
|
|========================================== | 60%
|
|=========================================== | 62%
|
|============================================ | 63%
|
|============================================== | 65%
|
|=============================================== | 67%
|
|================================================ | 68%
|
|================================================= | 70%
|
|================================================== | 72%
|
|=================================================== | 73%
|
|==================================================== | 75%
|
|====================================================== | 77%
|
|======================================================= | 78%
|
|======================================================== | 80%
|
|========================================================= | 82%
|
|========================================================== | 83%
|
|============================================================ | 85%
|
|============================================================= | 87%
|
|============================================================== | 88%
|
|=============================================================== | 90%
|
|================================================================ | 92%
|
|================================================================= | 93%
|
|================================================================== | 95%
|
|==================================================================== | 97%
|
|===================================================================== | 98%
|
|======================================================================| 100%## [1] "OK!"<
Lo usamos como alternativa a while, usualmente como pruebas. Se repite eternamente hasta que se active un operador break, por lo que hay que incluir uno o sino el loop será infinito. Como ultima opción, Ctrl C mata procesos de la terminal.
##
|
| | 0%repeat
{
i = i +1
setTxtProgressBar(pb, i)
Sys.sleep(.1)
if( !i<nrow(my.mat) ) {break} # Condicional para terminar
}##
|
|= | 2%
|
|== | 3%
|
|==== | 5%
|
|===== | 7%
|
|====== | 8%
|
|======= | 10%
|
|======== | 12%
|
|========= | 13%
|
|========== | 15%
|
|============ | 17%
|
|============= | 18%
|
|============== | 20%
|
|=============== | 22%
|
|================ | 23%
|
|================== | 25%
|
|=================== | 27%
|
|==================== | 28%
|
|===================== | 30%
|
|====================== | 32%
|
|======================= | 33%
|
|======================== | 35%
|
|========================== | 37%
|
|=========================== | 38%
|
|============================ | 40%
|
|============================= | 42%
|
|============================== | 43%
|
|================================ | 45%
|
|================================= | 47%
|
|================================== | 48%
|
|=================================== | 50%
|
|==================================== | 52%
|
|===================================== | 53%
|
|====================================== | 55%
|
|======================================== | 57%
|
|========================================= | 58%
|
|========================================== | 60%
|
|=========================================== | 62%
|
|============================================ | 63%
|
|============================================== | 65%
|
|=============================================== | 67%
|
|================================================ | 68%
|
|================================================= | 70%
|
|================================================== | 72%
|
|=================================================== | 73%
|
|==================================================== | 75%
|
|====================================================== | 77%
|
|======================================================= | 78%
|
|======================================================== | 80%
|
|========================================================= | 82%
|
|========================================================== | 83%
|
|============================================================ | 85%
|
|============================================================= | 87%
|
|============================================================== | 88%
|
|=============================================================== | 90%
|
|================================================================ | 92%
|
|================================================================= | 93%
|
|================================================================== | 95%
|
|==================================================================== | 97%
|
|===================================================================== | 98%
|
|======================================================================| 100%break termina el procesamiento del loop. Lo usamos cuando quremos terminar iteraciones, si por ejemplo se acumulan errores o se llego a un resultado deseado segun el condicional de un loop while.
threshold <- 5
for (i in 1:nrow(my.mat))
{
Sys.sleep(.1)
print(paste("lopping at ", i))
if (my.mat[i,][2] %>% as.numeric() > threshold)
{
print(paste("We superpass ", threshold))
break
}
} ## [1] "lopping at 1"
## [1] "We superpass 5"##
|
| | 0%while(i<nrow(my.mat))
{
i = i +1
paste('looping at ',i) %>% print
setTxtProgressBar(pb, i)
Sys.sleep(0.1)
if(i==5) break
}## [1] "looping at 1"
##
|
|= | 2%[1] "looping at 2"
##
|
|== | 3%[1] "looping at 3"
##
|
|==== | 5%[1] "looping at 4"
##
|
|===== | 7%[1] "looping at 5"
##
|
|====== | 8%next termina el procesamiento de la iteración actual y pasa a la siguiente. Lo usamos dentro del procesamiento, si por ejemplo la iteración actual fuese un error o no quisieramos incluirla en el procesamiento. Por ejemplo, si los valores procesados son outliers.
# Implementación verbosa
mis_numbs = NA
mis_letrs = NA
i = 0
p1 = 0
p2 = 0
for(i in 1:length(c(my.mat)))
{
my.item <- c(my.mat)[i]
if(!is.na( as.numeric(my.item)))
{
p1 = p1 +1
mis_numbs[p1] <- as.numeric(my.item)
next
}
p2 = p2 + 1
mis_letrs[p2] = my.item
}
mis_letrs## [1] "a" "w" "c" "k" "s" "j" "z" "t" "d" "y" "w" "m" "b" "h" "j" "m" "p" "d" "v"
## [20] "v" "u" "z" "q" "g" "n" "y" "b" "t" "o" "o" "b" "a" "h" "a" "a" "c" "v" "u"
## [39] "p" "m" "l" "a" "d" "u" "d" "l" "h" "k" "a" "c" "f" "n" "m" "v" "h" "c" "b"
## [58] "b" "t" "e"## [1] 8 7 5 4 4 7 10 7 1 10 7 8 7 10 9 1 5 1 10 1 2 6 8 9 4
## [26] 2 3 8 3 2 8 6 6 8 7 10 8 6 8 1 2 8 3 1 10 3 6 1 9 4
## [51] 6 5 9 1 4 6 10 7 6 6# Implementación tacaña
mis_numbs = NULL; mis_letrs = NULL; i = 0
for(i in 1:length(c(my.mat)))
{
my.item <- c(my.mat)[i]
if(!is.na( as.numeric(my.item)))
{
mis_numbs %<>% c(as.numeric(my.item)); next
}
mis_letrs %<>% c(my.item)
}
mis_letrs## [1] "a" "w" "c" "k" "s" "j" "z" "t" "d" "y" "w" "m" "b" "h" "j" "m" "p" "d" "v"
## [20] "v" "u" "z" "q" "g" "n" "y" "b" "t" "o" "o" "b" "a" "h" "a" "a" "c" "v" "u"
## [39] "p" "m" "l" "a" "d" "u" "d" "l" "h" "k" "a" "c" "f" "n" "m" "v" "h" "c" "b"
## [58] "b" "t" "e"## [1] 8 7 5 4 4 7 10 7 1 10 7 8 7 10 9 1 5 1 10 1 2 6 8 9 4
## [26] 2 3 8 3 2 8 6 6 8 7 10 8 6 8 1 2 8 3 1 10 3 6 1 9 4
## [51] 6 5 9 1 4 6 10 7 6 6# Implementación optimizada
mis_numbs = NULL; mis_letrs = NULL; i = 0
repeat
{
i=i+1
if(i>length(c(my.mat))){break}
my.item <- c(my.mat)[i]
if(!is.na( as.numeric(my.item)))
{
mis_numbs %<>% c(as.numeric(my.item)); next
}
mis_letrs %<>% c(my.item)
}
mis_letrs## [1] "a" "w" "c" "k" "s" "j" "z" "t" "d" "y" "w" "m" "b" "h" "j" "m" "p" "d" "v"
## [20] "v" "u" "z" "q" "g" "n" "y" "b" "t" "o" "o" "b" "a" "h" "a" "a" "c" "v" "u"
## [39] "p" "m" "l" "a" "d" "u" "d" "l" "h" "k" "a" "c" "f" "n" "m" "v" "h" "c" "b"
## [58] "b" "t" "e"## [1] 8 7 5 4 4 7 10 7 1 10 7 8 7 10 9 1 5 1 10 1 2 6 8 9 4
## [26] 2 3 8 3 2 8 6 6 8 7 10 8 6 8 1 2 8 3 1 10 3 6 1 9 4
## [51] 6 5 9 1 4 6 10 7 6 6mis_numbs = NULL; mis_letrs = NULL; i = 0
repeat{
i=i+1; if(i>length(c(my.mat))){break}
my.item <- c(my.mat)[i]
if(!is.na( as.numeric(my.item)))
{mis_numbs %<>% c(as.numeric(my.item))}
else
{mis_letrs %<>% c(my.item)}
}
mis_letrs## [1] "a" "w" "c" "k" "s" "j" "z" "t" "d" "y" "w" "m" "b" "h" "j" "m" "p" "d" "v"
## [20] "v" "u" "z" "q" "g" "n" "y" "b" "t" "o" "o" "b" "a" "h" "a" "a" "c" "v" "u"
## [39] "p" "m" "l" "a" "d" "u" "d" "l" "h" "k" "a" "c" "f" "n" "m" "v" "h" "c" "b"
## [58] "b" "t" "e"## [1] 8 7 5 4 4 7 10 7 1 10 7 8 7 10 9 1 5 1 10 1 2 6 8 9 4
## [26] 2 3 8 3 2 8 6 6 8 7 10 8 6 8 1 2 8 3 1 10 3 6 1 9 4
## [51] 6 5 9 1 4 6 10 7 6 6library(GEOquery)
library(tidyverse)
codes <- c('GSE159378', 'nada' , 'GSE159377', 'GSE154900', 'GSE151154', 'nada', 'GSE146754' )
metadata.list <- list()
for(i in 1:length(codes))
{
down.path <- NULL
try(getGEOfile(codes[i]) -> down.path)
if (down.path %>% is.null){next}
getGEO(filename=down.path) -> soft
soft -> metadata.list[[i]]
}## Error in file.exists(destfile) : objeto 'destfile' no encontrado
## Error in download.file(myurl, destfile, mode = mode, quiet = TRUE, method = getOption("download.file.method.GEOquery")) :
## no fue posible abrir la URL 'https://ftp.ncbi.nlm.nih.gov/geo/series/GSE159nnn/GSE159377/soft/GSE159377_family.soft.gz'
## Error in file.exists(destfile) : objeto 'destfile' no encontradoTitles <- NULL
for(i in 1:length(metadata.list))
{
metadata.list[[i]] -> extracted.metadata
if (extracted.metadata %>% is.null){next}
extracted.metadata %>% slotNames -> my.slots
for(j in 1:length(my.slots))
{
slot(extracted.metadata,my.slots[j] ) %>% names -> my.names
if(str_detect(my.names, '(t|T)itle') %>% any)
{
my.names[str_detect(my.names, '(t|T)itle')] -> my.title0
slot(extracted.metadata,my.slots[1])[[my.title0]] -> my.title
Titles %<>% c(my.title)
}
}
}
Titles## [1] "An enhancer cluster promotes NPCs formation from ESCs through maintaining HoxB activation by long-range chromatin interaction"
## [2] "Widespread traces of lytic KSHV in primary effusion lymphoma at single-cell resolution"
## [3] "Global analysis of kidney gene expression by RNA-Seq of aged CTRP1-deficient mice on high-fat diet"
## [4] "Smc3 regulates B-cell transit through germinal centers and restricts their malignant transformation (RNA-seq)"FONDECYT Postdoctoral Fellow, Universidad de Chile, deepen.data@gmail.com↩︎
Pregrado, Universidad de Chile↩︎