knitr::opts_chunk$set(echo = TRUE)

getwd() # nos dice el directorio de trabajo actual
setwd("c:/R/PROYECTOS") #establece la ruta dada como directorio de trabajo

ls() #lista los objetos actuales en memoria
list.files() #lista los ficheros en el directorio actual
dir() # lo mismo que list.files


# CREAR UN DIRECTORIO
dir.create("testdir") # crea un directorio en el wd actual con el nombre testdir

file.exists("mytest.R") # si TRUE es el que fichero existe
file.rename("mytest.R", "mytest2.R")# cambia el nombre de  a 2
file.copy("mytest2.R", "mytest3.R")
dir.create(file.path("testdir2","testdir3"),recursive = TRUE) # CREA dos directorios recursivamente

# BORRAR DIRECTORIOS CUIDADIN!!
unlink("testdir",recursive = TRUE) #BORRA LOS DIRECTORIOS

# Borrar todas las varibles del entorno en R
rm(list=ls())

#data es un df
is.na(data) # es true para todos los valores NA
!is.na(data) # es true para todos los valores no NA

# Por ejemplo convertir los ceros 0 a NA
df[df == 0]<-NA

#nombrecol es el nombre de la columna o num de columna
#entonces filtro almacena los valores que no son NA
    filtro <- data[ !is.na(data[nombrecol]), ]
    colsinNA <- data[, nombrecol]
    
#si son valoresnumericos podemos saber el max min etc de este modo
    rowNum <- which.min(colsinNA) ##return the nrow of the min value 
    nombre <- data[rowNum, ]$name
   
   
    rowNum <- which.max(colsinNA) ##return the nrow of the max value   

#data es un df
# esto ordena el df con dos criterios, primero según los valores de la col 1 y despues caso de empate por col 3
  data_ordenado <- data[order(data[1],data[3],decreasing = FALSE),]

 ## selec char values per col
    data <- data[data[outcome] != 'Not Available', ]

## Convierte a numeric la columna 3 del df
    data[3] <- as.data.frame(sapply(data[3], as.numeric))

# Quita las columnas que son todo NA
DT[,which(unlist(lapply(DT, function(x)!all(is.na(x))))),with=F]

#Estas otras opciones para quitar los ceros
df[,colSums(is.na(df))< nrow(df)])
select(df,df[,colSums(is.na(df))< nrow(df)])
df<-df[,colSums(df != 0) != 0]

# leer un dt con fread
#1. cargar la librería de data table
library(data.table)
DT <- fread(input="./data/e5.csv", sep=",")
file.info("./data/e5.csv")$size
#calcular media de una columna y split de otra
DT[,mean(colA),by=colB])
# que es lo mismo que:
sapply(split(DT$colA,DT$colB),mean)
# lomismo con split
subset1<-split(DT$colA,DT$colB)
#esto lo dibide en dos, y podemos sacar la media de cada uno
summary(subset1[[1]])

#Guardar datos como un fichero
DT<-write.table(big_df, file=file, row.names=FALSE, col.names=TRUE, sep="\t", quote=FALSE)
system.time(fread(file))

# Función que estima la cantidad de memoria usada por una matriz de filas x col
# según sea integer o numeric

predict_data_size <- function(numeric_size, number_type = "numeric") {
  if(number_type == "integer") {
    byte_per_number = 4 # 4 bytes por numero entero
  } else if(number_type == "numeric") {
    byte_per_number = 8  # 8 bytes por numero
  } else {
    stop(sprintf("Unknown number_type: %s", number_type))
  }
  estimate_size_in_bytes = (numeric_size * byte_per_number)
  class(estimate_size_in_bytes) = "object_size"
  print(estimate_size_in_bytes, units = "auto")
}
# Ejemplos
predict_data_size(1304287*28, "numeric")
predict_data_size(1518*1518, "integer")

datos_leidos <- read.table("nombre_fichero.txt", 
                skip = numero_de_fila_desde_donde_empieza_a_leer,
                nrows = num_filas_que leer,
                sep = ";", na.strings = "?",
                col.names= vector_nombres_de_col )

pm1<- read.table("nombre_fichero.txt", comment.char = "#", header = FALSE, sep = "|", na.strings = "")
# vemos la dimension del fichero
dim(pm0)
head(pm0)
# vamos a asignar los nombres de las columnas, que vemos que estaban en la primera fila del fichero
cnames<- readLines("nombre_fichero.txt",1) # lee la fila 1
# vemos que los nombres están separados por |, hacemos un 
# split de los datos
cnames<-strsplit(cnames, "|", fixed = TRUE)
# asignamos como nombres de col el primer elemento de la lista de cnames
names(pm0)<-cnames[[1]]

setwd("C:/....") #establece el directorio de trabajo
#almacena en files_full la ruta relativa de cada fichero, 
# si solo queremos el nombre poner full.names=FALSE
files_full<-list.files(pattern = '.jpg',full.names=TRUE) #lee todos los ficheros en el dir

#instalamos el paquete que lee los datos exif
install.packages("exifr")
#cargamo la librería
library("exifr", lib.loc="~/R/win-library/3.3")

setwd("C:/TITAN/FOTOS") #establece el directorio de trabajo donde están las fotos
files_full<-list.files(pattern = '.jpg',full.names=TRUE) #lee todos los ficheros en el dir
#llamamos a exifr que es la funcion del paquete que lee las fotos y extrae un data frame con todos los 
#datos EXIF
exifinfo <- exifr(files_full)

#lee un fichero de datos
data <-read.csv(nombrefichero)

#quitamos los NA de la columna 4
    data1 <- data[!is.na(data[4]), ]

#alternativamente si quiero solo casos completos:
# las filas que tienen datos validos en todas las columnas 
    data1<-na.omit(data)
    # si quiero sabe cuantas observaciones tengo
    nobs<- nrow(na.omit(data))

data <- read.csv("data/outcome-of-care-measures.csv", stringsAsFactors=FALSE, na.strings="Not Available")
# seleccionamos de la columna 3 los datos validos , no NA
data1 <- data[!is.na(data[3]), ]

#creamos un vector
x<-1:100
#seq_along(x) crea una secuencia de 1 a el lenght(x)..
    for (i in seq_along(x)) {   
        x2 <- x[i]*2
    }

# leer encabezados y hacer trim a los datos
# strip.white = quita espacios blancos antes y despues=trim
  tabla<-read.csv("loans.csv",header = TRUE, strip.white=TRUE)

getwd()
ruta<-"C:/R/proyectos/INFORMES/OJOS"
setwd(ruta)
#Cambiar espacio por _ en los nombres de ficheros de un directorio
imagenes<-list.files("./imag/",pattern = ".jpg")
imagenes
length(imagenes)
limpia<- function (x) gsub('([[:punct:]])|\\s+','_',x); # quita los simbolos raros
limpian<- function (x) gsub('ñ','n',x); # quita las ñ por n

setwd("C:/R/proyectos/INFORMES/OJOS/imag")
## Código para cambiar el nombre de los ficheros de un directorio
## eliminando espacios en blanco

for (i in seq_along(imagenes)){
    a<-limpia(substring(imagenes[i],1,nchar(imagenes[i])-4))
    a<-limpian(a)
    a<- paste(a,".jpg", sep = "")
    file.rename(imagenes[i],a)# cambia el nombre de  a 2
}

################################################################
## crea código LATEX para insertar las imagenes de un directorio
################################################################

ruta<-"C:/R/proyectos/INFORMES/OJOS"
setwd(ruta)
getwd()
imagenes<-list.files("./imag/",pattern = ".jpg")

sink("imagenes.rmd") #abro la conexion con el fichero
cat("# cod para insertar las imagenes de un directoio en markdown")
cat("\n") #salto de linea
## Empieza la figura

# hago un loop para todas las subfiguras
for (i in seq_along(imagenes)){
    #i<-1
    nom<- substring(imagenes[i],1,nchar(imagenes[i])-4)
    nom
    line<-paste("![", nom," \\label{fig_", i , "}](imag/", imagenes[i] ,")", sep="")
    line
    cat(line)
    cat("\n")
}

sink()# cierro la conexion

################################################################
## crea código LATEX para insertar las imagenes de un directorio
## en un informe R markdown.
################################################################

ruta<-"C:/R/proyectos/SCADA/ulea"
setwd(ruta)
imagenes<-list.files("./imag/" )
length(imagenes)
## writeLines(line,"figurasLatex.tex", sep = "\n", useBytes = FALSE)

limpia<- function (x) gsub('([[:punct:]])|\\s+','_',x);
limpian<- function (x) gsub('ñ','n',x); # cambia las ñ por n en los nombres
#Escribir en fichero con CAT
fecha<-Sys.Date()
sink("figurasLatex.tex") #abro la conexion con el fichero
cat("% NUEVO ANEXO FOTOGRAFICO")
cat("\n")
cat(paste("% fer -",fecha,sep=""))
cat("\n") #salto de linea
## Empieza la figura
line<-"\\begin{figure}[h] \\centering"
cat(line)
cat("\n")
# hago un loop para todas las subfiguras
for (i in seq_along(imagenes)){
    line<-""
    line<-paste(line,"\\subfigure[",imagenes[i],"]{\\includegraphics[width=0.45\\linewidth]{imag/", imagenes[i],"}}", sep="")
    #write(line,file="figurasLatex.tex",append=TRUE)
    cat(line)
    cat("\n")
    if(i%%2==0){
        cat("\\\\")
        cat("\n")
    }
}

cat("\\caption{figuras}\\label{fig.fig1}")
cat("\\end{figure}")
sink()# cierro la conexion

library(httr) 
url <- "https://d396qusza40orc.cloudfront.net/getdata%2Fprojectfiles%2FUCI%20HAR%20Dataset.zip"
file <- "datos.zip"
if(!file.exists(file)){
    print("descargando")
    download.file(url, file, method = "wininet")
}

# Unzip and create folders 
datafolder <- "UCI_HAR_Dataset"
resultsfolder <- "results"
if(!file.exists(datafolder)){
    print("unzip file")
    unzip(file, list = FALSE, overwrite = TRUE)
} 

if(!file.exists(resultsfolder)){
    print("create results folder")
    dir.create(resultsfolder)
} 

# 0) Read txt and convert to data.frame in folder UCI HAR Dataset

setwd("C:/R/proyectos/C3_course_project/UCI HAR Dataset/")

# Read general data
features     = read.table('features.txt',header=FALSE); #imports features.txt
activityType = read.table('activity_labels.txt',header=FALSE); #imports activity_labels.txt

#EJEMPLO 1
# descargamos los datos de invertia del IBEX35
library("XML", lib.loc="~/R/win-library/3.3")
library(XML)

#direccion url con al menos una tabla
t_invertia ="https://www.invertia.com/mercados/bolsa/indices/ibex-35/acciones-ib011ibex35"

# con "which" indicamos qué tabla de la web descargamos, en este caso la 2 que corresponde con los valores del IBEX
t_invertia.table = readHTMLTable(t_invertia, header=T, which=2,trim = TRUE,stringsAsFactors=F)
t_invertia.table
names(t_invertia.table)
nom<-c("TKR","último", "Dif","Dif. %", "Open","Max","Min", "Vol","Cap", "Rt/Div",  "BPA", "PER","Hora")
names(t_invertia.table)<-nom
#quitar los n.a y n.d de la tabla y poner como NA
t_invertia.table[t_invertia.table == "n.d."]<-NA
t_invertia.table[t_invertia.table == "n.a."]<-NA
## Bucles <a name="bucles"></a>
### Bucle que recorra un vector <a name="b1"></a>

# Descargar de la web el fichero siguiente csv
fileUrl<-"https://d396qusza40orc.cloudfront.net/getdata%2Fdata%2Fss06hid.csv"
# lo guardamos en la carpeta local como p1.csv
download.file(fileUrl, destfile="p1.csv")

# leemos su contenido
p1 <- read.table("p1.csv", sep="," , header= TRUE)
# Leemos la variable VAL que continene el valor de las casas
tmp<-p1$VAL
tmp<-tmp[!is.na(tmp)] # seleccionamos los validos quitamos NA

# leemos enel code book que un valor de 24 significa que el
# valor  de la casa es de 1 millon o más.
tmp<-tmp[tmp>=24]
# La respuesta de cuantos hay de mas de un millon es 53
pregunata1<- length(tmp)

con <- url("https://biostat.jhsph.edu/~jleek/contact.html")
htmlcode <- readLines(con)
close(con) # SIEMPRE CERRAR CONEXION

nchar(htmlcode[10])
nchar(htmlcode[20])
nchar(htmlcode[30])
nchar(htmlcode[100])

# open a connection to the database
ucscDb<-dbConnect(MySQL(),user = "genome",host = "genome-mysql.cse.ucsc.edu")
db = "hg19" #= select specific database
result<- dbGetQuery(ucscDb,"show databases;")
dbDisconnect(ucscDb)

# install sqldf package using below command
# install.packages("sqldf")
# Load sqldf package
library(sqldf)

fileurl <- "https://d396qusza40orc.cloudfront.net/getdata%2Fdata%2Fss06pid.csv"
download.file(fileurl, destfile="./US_community_survey_data.csv")
acs <- read.csv("./US_community_survey_data1.csv", header=TRUE)

sqldf("select distinct AGEP from acs")

best <- function(state, outcome) {
    ## Error handling
    ## Validate the outcome string. Valid values:
    possibleoutcomes = c("heart attack", "heart failure", "pneumonia")
    if( outcome %in% possibleoutcomes == FALSE ) stop("invalid outcome")
    
    ## Validate the state string
    states <- data[, 2]
    states <- unique(states) ##use unique to extract just one value without repeat
    if( state %in% states == FALSE ) stop("invalid state")    
    
    ## Validate the num value 
    ## &&=AND  num%%1
    if( num != "best" && num != "worst" && num%%1 != 0 ) stop("invalid num")

}

#cortar los espacios del inicio y fin
trim <- function (x) gsub("^\\s+|\\s+$", "", x)

#dar la vuelta a una palabra
strReverse <- function(x){
  sapply(lapply(strsplit(x, NULL), rev), paste, collapse = "")
}

#substituir caracteres de un texto
descripcion<-"sajsasjj jlakjs lajs lajs \n asa"
descripcion <- gsub("\n"," ",descripcion, fixed = TRUE)

# Buscar un patron de texto
#da como resultado el id del elemento del vector que lo contiene
txt <- c("arm","foot","lefroo", "baFoobar")
grep("foo", txt,ignore.case=TRUE)
# txt[2] y txt[4] lo contienen, el resultado es un vector (2, 4)

grep("[a-z]", letters)
# obtiene un vector con las id de las letras de 1 a 26

cnames<-"col1 | col2 | nombre tres| asa"
cnames<-strsplit(cnames, "|", fixed = TRUE)
# como algunos nombres tienen espacios lo arreglamos con la funcion make.names
# que cambia espacios por puntos
cnames<- make.names(cnames[[1]])

# crear una nueva variable class POSIXlt
data$DateTime <- strptime(paste(data$Date, data$Time, sep=" "), "%d/%m/%Y %H:%M:%S")

library(stringr)

#Quitar espacios delante y detras de un string
str_trim(string) # si se especifica side=c("left")

if (!require("png")) {
   install.packages("png", dependencies = TRUE)
   library(png)
   } 

# 1. comprobamos que no está
find.package("devtools")

# 2. si está lo cargamos así 
library(devtools)
find_rtools()

source("https://bioconductor.org/biocLite.R")
biocLite()

#Paquetes disponibles 
#a<-- available.packages()
   head(rownames(a),3) ## muestra solo los nombres de las primeras lineas

# Para saber los argumentos de una funcion:
args(list.files) # da la lista de argumentos de una fucnion
args(grep)

#########################################
##  SUBDIVIDISION DE  VARIABLES
##  CREACION DE SUBCONJUNTOS
#########################################

#Creamos un data frame
set.seed(13435)
x<- data.frame("var1"= sample(1:5),"var2"= sample(6:10),"var3"= sample(11:15))
x<-x[sample(1:5),];x$var2[c(1,3)]=NA
x

# Seleccionar una columna por numero
x[,1]
# Seleccionar columna por name
x[,"var1"]

# Seleccionar parte de una fila y columna a la vez
x[1:2,"var2"]

# Seleccionar con operadores lógicos
# selecciono los valores que cumplen esta condición en todas las columnas
x[(x$var1<=3 & x$var3 >11),] # AND 

x[(x$var1<=3 | x$var3>15),] # OR


# Seleccionar con which
x[which(x$var2>8),]
x[(x$var2>8),]  # ver diferencia respecto a NA

# subconjunto de una columna que ademas contenga ciertos valores
x2<-x[x$var3 %in% c(4,56,23)] # crea nueva tabla con la columna var3
                              # pero solo las filas que valen 4, 56 y 23

#########################################
##  ORDENAR VARIABLES
#########################################

# Ordenar una columna ascendiente por defecto
sort(x$var1)

# ordenar por orden decreciente
sort(x$var1, decreasion=TRUE)

# ordenar y poner los NA al final
sort(x$var1, na.last=TRUE)

# Ordenar toda el data frame según una columna
x[order(x$var1),] # ordeno por la columna var1


#Ordenar por varias variables
x[order(x$var1,x$var3),] # ordeno por la columna var1

#####################################
# Añadir una columna nueva al data frame directamente
x$var4<- rnorm(5)

#Añadir columnas nuevas
y<- cbind(x,rnorm(5)) # la añade en la ultima columna
y<- cbind(rnorm(5),x) # añade una columna en la primera columna

# Añade una fila nueva 
y<-rbind(c(1,2,3,4,5,6),x)

###########################
# SUBTOTALES CON TAPPLY
#########################
  # por ejemplo si queremos la suma de la colA, según cada valor de la colB de un data frame
  tapply(df$colA,df$colB,sum)
  #probar dcast(df, df$colA ~ df$colB, sum)
  #Otra opcion es con split
  res<- lapply(split(df$colA,df$colB),sum)
  unlist(res)
  sapply(res, sum)

#####################################
# sumar elementos de un split doble
# lista de listas
# hacemos un doble split
df_split<-split(BaltCity,list(BaltCity$year,BaltCity$type))

# rutina para obtener la suma de un elemento de segundo nivel en una lista de listas.
# cogemos la suma de cada elemento 1 de cada lista principal del split
resum_df<- data.frame()

for (i in seq(df_split)){
    # cambia 1 por la columna de la sublista que queramos resumir
    resum_df<-rbind(resum_df,sum(df_split[[i]][,1]));#,names(df_split)[i]); 
}
# añadimos el nombre
resum_df<-cbind(resum_df,names(df_split))
resum_df

# crear tabla relacional split doble con xtabs
# here are 3 ways of calculate the cros data table
# 1. xtabs
    xt<-xtabs(Emissions~year + type,BaltCity) # emision year y taype son columnas del data frame BaltCity
    # to test the results take a look at some
    # sum(BaltCity[BaltCity$year == 1999 & BaltCity$type == "POINT",1])
# 2. aggregatee
     xta<-aggregate(Emissions ~ year + type, BaltCity, sum)
# 3. library(dplyr)
     xta <- nei %>%
        filter(fips == 24510) %>%
        group_by(year, type) %>%
        summarize(total.emissions = sum(Emissions))

set.seed(10) # genera semilla aleatoria
x <- rnorm(100) # genera 100 numeros normales entre 0-1

# creamos un factor
f <- rep(0:1,each=50) # repite 0 50 veces y 1 otras 50
#para convertir en factor
f<-factor(f,labels=c("Grupo 1", "Grupo 2"))

#crear variable aleatoria de yes y nos
yesno<- sample(c("yes", "no"), size=10, replace=TRUE)
#crear factor
yesnofac<-factor(yesno, levels=c("yes", "no"))
as.numeric((yesnofac))
#yes=1, no 2...

# si lo quiero cambiar el orden de los factores
yesnofac<-relevel(yesnofac, ref="no")
as.numeric((yesnofac))
 

set.seed(1)
n<-1000 # numero de lanzamientos de moneda o tirada
# size es el numero de monedas que lanzamos en la misma tirada, y lo que da es la suma de los resultados. p ejm size 5 =3 caras + 2 cruces...
lanzamientos=rbinom(n,size=1,prob = 0.5)
table(lanzamientos)

# dividir en 3 partes iguales una variable numerica diamonds$carat
# calculamos los puntos de corte 3+1=4
cutpoints<-quantile(diamonds$carat,seq(0,1,length=4),na.rm=TRUE)

#creamos la nueva variable en la dataframe diamons
# cut(variable_a_cortar, puntos_de_corte)
diamonds$car2<-cut(diamonds$carat,cutpoints)
#ojo que los valores iguales al min los excluye en otra categoría
levels(diamonds$car2).