FULTON

#1.3. Formato del código en el texto

# Este es un comentario; en R los comentarios empiezam

# a partir del caracter ‘#’.
#----------------
# En seguida asignaremos mediante codigos de R al valor 2014 a una
# variable llamada ‘x’:
x<- 2014
#Ahora se imprimirá el valor de la variable dos veces, la primera
#vez se hará de manera explíta por medio de la funcion print() ,
#como sigue:
print(x)
##[1]
# … en seguida se imprimirá de manera implícita, simplemente
#’tecleándola’ en la consola
x
##[1] 2014
# Finalmente haremos una multiplicacion de x por 2
2*x
## [1] 4028
#Notemos que las impresiones o resultados de estas operaciones
# apracecen como comentarios, pero iniciados con ‘##’y con
# una tipografia diferente que los comentarios usuales.

#1.5. Ayuda en R

#Una forma abreviada sería

?lm #-- comentario
help(“[[“)
help(‘if’)
[Link](“split”)
# 0 abreviadamente
??”split”

#Los datos numéricos

x<- 2 # se asigna el valor de 2 a x
print(x) # se imprime el valor de x
## [1] “numeric”
x<-6/2 # Se asignará el valor de la operación 6/2 a x
print (x)
##[1] 3
class(x)
## [1] “numeric”
x<- 23L; print(x)
## [1] 23
class(x)
## [1] “integer”
x<- [Link](6/2); print(x)
## [1] 3
class(x)
## [1] “integer”

x<- 21 + 2i
y<- 2i + 21 # El mismo valor de x
z<- -1+0i #corresponde a -1
tt<- sqrt(z) #raiz cuadrada de -1

## [1] 21 + 2i
## [1] 21 + 2i
## [1] -1 + 0i
## [1] 0+1i

class(tt)
## [1] “complex”

x<- 1/0 # División para 0

x

## [1] Inf
#Tambien dividir un numero por Inf da cero:
y<- 1/inf
y
##[1] 0

x<-0/0
x
## [1] NaN

KELLY
# 2.2 Vectores
x<-2 #se ha asigando el valor 2 a la x
print(x) #se imprime el valor de x
-----------------------------------------------------------
#2.2.1 El uso de la función c() para crear verctores
c(4,2,-8) #Creación de un vector sin asignarlo a una variable
##Distintas formas de asignar un vector a una variable
u <-c(4,2,-8) #Usando el operador <-
c(4,2,-8) -> v #Usando el operador ->
#Usando la función assign:
assign("w",c(4,2,-8))
p = c(4,2,-8) #Usando el operador =
print(u);print(v);print(w);print(p)
-----------------------------------------------------------
#2.2.2 Creación de vectores a partir de archivos de texto-la función scan()
vec<-scan("[Link]") #debe haber un archivo con contenido
print(vec)

vec<-scam("nombre-del-archivo-txt",integer())#para indicar el tipo de vector

print(vec); class(vec) #El vector y su clase

#función inversa#
vv<-(5,6.6,-7.7)
write(vv,"[Link]") #para transformar un vector en archivo

v1<-scan("[Link]") #para recuperar el contenido del archivo

v1
-------------------------------------------------------------
#Creación de vectores a partir de secuencias y otros patrones

v<-vector("integer",0)
v #un vector de enteros sin elementos
w<-vector("numeric",3)
w #Un vector de tres ceros
u<-vector("logical",5)
u #Un vector de 5 FALSE

1:3 # El operador " : " permite crear un vector a partir de secuencia

v<- 39:11
print(v); class(v) #El vector y su clase

v<- pi:6 #con números no enteros

print(v);class(v)

v<-seq(from=5,to=15,by=2)
print(v) #secuencia desde 5 hasta 15 de 2 en 2

v<-seq(from=4,by=2,[Link]=8) #determina un vector en base a una longitud

print(v) #secuencia de 8 números iniciando desde 4 y de 2 en 2

v<-c(4,8,-3)
w<-rep(v,times=5)
print(w)#repetir los elementos del vector varias veces en un vector

u<-c(3,4,5)
v<-c(5,4,3)
w<-c(u,v)
print(w) #La concatenación de u y v

--------------------------------------------------------------
#2.2.4. Acceso a los elementos individuales de un vector

v<-c(8,7,-3,2,182)
v[4] #El cuarto elemento
print(v[1]);print(v[3]) #el primero y el tercer elemento
v[4]+v[2] #La suma de cuarto y el segundo elemento de v
v[1]<-v[2]-v[5]
v #El resultado de la operación se guarda en la posición 1

v[8]<-213 #para hacer crecer el vector

v #v tiene ahora 8 elementos con espacios vacíos

#se puede asegnar números a palabras

frutas<-c(15,100,2,30)
frutas
names(frutas)<-c("naranja","pera","manzana","durazno")
frutas

#otra manera de nombrar los elementos de un vector

frutas<-c(naranja=15,pera=100,manzana=2,durazno=30)
frutas["durazno"]

frutas["manzana"] <-8 #para asignar nuevos valores a las palabras

frutas

#El acceso a través de índices sigue permitiendo:

frutas[2]
--------------------------------------------------------------
#Operaciones sencillas con vectores

v<-2+3
v #un vector de longitud uno

v<-c(2,3)-c(5,1)
v # un vector de longitud 2

v<-c(2,3,4)*c(5,1,4)
v # un vector de longitud 3

v<-c(2,3,4)-c(3:1) #Eleva a potencias 3,2,1

v

u<-2:30
v<-c(4,5,6)
w<-c(u,v) #unión de vectores
w
length(w) #mide el tamaño del vector

w<=10 #Prueba elementos menores o iguales a 10

v<-c(4,5,6,7,8,9,10)*c(1,2)
v

v<-c(4,5,6,7,8,9,10)*c(2,2,1,2,3,1,2)
v

options(warn=-1) #indica las diferencias entre las logitudes de los operandos

v<-c(4,5,6,7,8,9,10)*c(1,2)
v

v<-c(4,5,6)
w<-2*(v^2) #dos veces el cuadrado de v
w

#Se desea la raíz cuadrada de los siguientes valores:

v<-c(9,8,31)
sqrt(v)

#El sin de 30,45 y 60 grados: primero de convierte en radianes

ángulos<-c(30,45,60)*(pi/180)
ángulos #en radianes

senos<-sin(ángulos)
senos
---------------------------------------------------------------
#Ejemplo de aplicación

#De un edificio, a una altura de 15m, se ha lanzado con águlo de 50 grados, un proyectil
#a una velocidad de 7m/s ¿Cuáles serán las alturas del proyectil
#a cada 0.5m de distanci horizontal desde donde se lanzó hasta los 11m?

g<-9.81 #aceleración gravedad

x0<-0 #x inicial
y0<-15 #y inicial
vi <-7 #velocidad inicial
alphaD <-50 #ángulo-grados

#Se convierte a radianes

alpha<-(pi/180)*alphaD
vox <-vi*cos(alpha) #componente x de velocidad inicial
vox
voy<-vi*sin(alpha) #componente y de velocidad inicial
voy

#desde 0 hasta 11 de 0.5 en 0.5

las.x <-seq(from=0,to=11,by=0.5)
las.t <-(las.x-x0)/vox

las.y <- -(g/2)*las.t^2+voy*las.t+y0

las.x
las.y
----------------------------------------------------------------
#2.3 Matrices
#2.3.1 Construcción de matrices

(m<-11:30) #Un vector con 20 números

#Para convertir en matriz simplemente se especifica el atributo dim

dim(m)<-c(4,5) #4 renglones y 5 columnas
m
class(m)

dim(m)<-c(5,4) #5 renglones y 4 columnas

m
Y el elemento en el renglon 3 y columna 2 es:
m[3,2]
m[8]#acceso al mismmo elemento, como vector, con un solo índice

#El renglón 3 y la columna 2 de la matriz

m[3,]
m[,2]

#La clase las columnas o renglones:

class(m[3,])

#ASIGNAR NOMBRES A LAS FILAS

(m<-matrix(11:30, nrow=5, ncol=4, byrow=TRUE))

rownames(m) <-c("uno","dos","tres","cuatro","cinco")
colnames(m) <-c("UNO","DOS","TRES","CUATRO")

#Consulta de los nombres de las columnas

colnames(m)
#Una columna:
m[,"DOS"]

m1<-rbind(c(1.5,3.2,-5.5),c(0,-1.1,60))
m1
class(m1[1,])

(m2<-cbind(c(1.5,3.2,-5.5),c(0,-1.1,60)))

PAUL
#MULTIPLICACION DE ELEMENTOS MATRICIALES
#La multiplicacion se hara elemento a elemento
#Se crea la matriz m, asignando un rango y el numero de filas y columnas
(m <- matrix(11:40, nrow = 5, ncol = 3))
(mm <- rbind(11:13, 23:21, c(21, 21, 21), c(22, 22, 22), c(13, 13, 13)))
m * mm
# [,1] [,2] [,3]
#[1,] 11 16 21
#[2,] 12 17 22
#[3,] 13 18 23
#[4,] 14 19 24
#[5,] 15 20 25

#MULTIPLICACION MATRICIAL
#Las matrices se multiplicarán entre sí, de acuerdo con las condiciones del Álgebra Lineal
(A<-matrix(11:16,2,3))
(B <- rbind(2:3, 2:3, 0:1))
#Para este fin, ha de usar el operador %*%
A%*%B
#[,1] [,2]
#[1,] 48 87
#[2,] 52 94

#MULTPLICACIÓN DE UNA MATRIZ POR SU TRANSPUESTA

t(A) #Comando para encontrar la transpuesta de una matriz
A%*%t(A)

#EJEMPLO
#Supóngase ahora, que se tiene un triángulo, cuyos vértices son (1.0, 0.0),
#(2.0, 1.0), y (1.0, 1.0), y se quieren encontrar los vértices del triángulo resultante
#de una rotación de 32º. Tómese en cuenta que el lenguaje R, provee de las
#funciones trigonométricas sin(), cos(), así como del número pi.
a=32*pi/180
(original=rbind(c(1, 2, 1),c(0, 1, 1)))
(traslacion=cbind(c(cos(a),sin(a)),c(-sin(a),cos(a))))
([Link]=traslacion%*%original)
#[,1] [,2] [,3]
#[1,] 0.8480481 1.166177 0.3181288
#[2,] 0.5299193 1.907887 1.3779674

#FACTORES Y VECTORES DE CARACTERES

persona <- c("Hugo", "Paco", "Luis", "Petra", "Maria", "Fulano",
"Sutano", "Perengano", "Metano", "Etano", "Propano")
[Link] <- c("Dic", "Feb", "Oct", "Mar", "Feb", "Nov",
"Abr", "Dic", "Feb", "Oct", "Dic")
print(c(persona[7],[Link][7]))
#[1] "Sutano" "Abr"
paste(persona[4],"nació en el mes de",[Link][4])
paste(persona[2],"nació en el mes de",[Link][2])
paste(persona[5],"no nació en el mes de",[Link][1])

#FACTORES Y SU ESTRUCTURA
[Link] <- [Link]([Link]) #El comando [Link] extrae los factores del
vector automaticamente
[Link]
# y generamos la impresión ahora con el factor:
paste(persona[7], "nacio en el mes de", [Link][7])

unclass([Link]) #Esta funcion permite asignar números a las categorías

pertenecientes a las variables
table([Link]) #Permite ver una tabla de frecuencias tomando en cuenta todas las
categorías

#Ahora vamos a especificar los niveles requeridos con el comando factor.

#Primero hay que crear el vector con nuestros niveles
meses <- c("Ene","Feb","Mar","Abr","May","Jun","Jul","Ago",
"Sep","Oct","Nov","Dic")

[Link] <-factor([Link], levels=meses)

[Link]
table([Link])
#Ene Feb Mar Abr May Jun Jul Ago Sep Oct Nov Dic
#0 3 1 1 0 0 0 0 0 2 1 3

#Se pueden extraer tanto los factores como los niveles:

[Link][10] #Extraer el nivel de la lista original
levels([Link])[6] #Se extrae un nivel de la lista depurada
#O bien, cambiarlos
levels([Link])[6]<-"octubre"
[Link]

#Si se quiere tener acceso al factor como un vector de índices, se convierte a entero:
[Link]([Link])
## [1] 2 3 6 4 3 5 1 2 3 6 2

#LISTA
familia<-list("Petronila", "Javier", 20, c("Humberto", "Cristina"), c(16,10))
familia

familia<-list(mama="Petronila", papa="Javier", casados=20, hijos=c("Humberto",

"Cristina"),edades= c(16,10))
familia

#Acceso a elementos listados

familia$mama
familia[["mama"]]

familia$papa<-"Daniel"
familia

familia$"mama" <- "Julia"

mm <- "mama"
familia[[mm]]

familia[[ paste("ma", "ma", sep="") ]]

familia

#DATA FRAMES

(m <- cbind(ord=1:3, edad=c(30L, 26L, 9L)) )

(v <- c(1.80, 1.72, 1.05) )
ff <- [Link](familia=c("Padre", "Madre", "Hijo"),m, estatura=v)
ff

#Pendiente de revisión por el tipo de archivo

[Link] <- [Link]("[Link]")
colnames([Link])
rownames([Link])
[Link]$Piso
[Link][[2]]
[Link][2]
[Link][3, 2]
# modificamos el elemento con:
[Link][3, 2] <- 106
[Link]
[Link]$Calentador
class([Link]$Calentador)
[Link]$Total <- [Link]$Precio * [Link]$Area
[Link]

#FUNCIONES
[Link]<- function(r, h) {h*pi*r^2}
class([Link])
[Link]<- function(r, h) {return(h*pi*r^2)}
[Link](5,1)

hipotenusa <- function(x, y) {return(sqrt(x^2 + y^2))}

hipotenusa(3, 4)
hipotenusa(y = 4, x = 3)

#Se puede dejar asignados valores a la funcion, para llamarla mediante variables ausentes
[Link] <- function(r=5, h=1) {h*pi*r^2}
[Link]()

#Área del círculo

ff <- function(r) {return(a * r^2)}
#Donde:
a=pi
ff(10)

LAURA

2.8 Coerción

x <- 1.03
y <- [Link](x) # conversión a entero
z <- [Link](y) # conversión a complejo
a <- c("1000", "2013.1", "0")
class(a)
b <- [Link](a) # conversión de character a otro tipo
class(b)

c <- [Link](b) # conversión a lógico

# 0 es FALSE y distinto de 0 es TRUE

#Conversión de una matriz a un data frame:

(m <- matrix(1:20, nrow = 5, ncol = 4))

ff <- [Link](m)

ff$V2 #acceso a los elementos del data frame

#CAPÍTULO 3

#3.1 Los operadores de acceso o selección

mtx[2,3] # regresa un objeto de la misma clase que el original # selecciona más de un elemento.
ff[[“Nombre”]] # extrae elementos de una lista
ff$Nombre #extrae o accede a los elementos de una lista o un data frame, a partir del nombre del
elemento.

#[Link]. Selección de una secuencia de elementos, o elementos particulares

(v <- rnorm(20)) # genera números aleatorios con una distribución normal

(subv <- v[5:15]) # selecciona números en posiciones específicas (entre 5 y 15)
(sub1.v <- v[c(2, 3, 5:8)]) #selección de subconjuntos arbitrarios del vector o factor.

([Link] <- factor(c("Dic", "Feb", "Oct", "Mar", "Feb", "Nov"),

levels=c("Ene","Feb","Mar","Abr","May","Jun", "Jul","Ago","Sep","Oct","Nov","Dic"))) #con factores

(sub2.v <- v[-c(2, 3, 5:8)]) # el índice negativo excluye los elementos señalados por el índice}

#[Link]. Selección de elementos de acuerdo con una condición

v[v < 0] #obtención de elementos negativos en el vector original

v[!(v < 0)] # obtención de elementos positivos mediante negación lógica
v[v >= 0] #obtención de numeros positivos con el operador >=
[Link] == "Mar" # probar igualdad en factores
[Link] != "Mar" # probar desigualdad en factores
[Link]([Link]) # factor convertido a enteros establecido por orden de los Levels
[Link]([Link]) <= 4 # vector de lógicos menores a 4
[Link][[Link]([Link]) <= 4] # índice (lista) menores a 4
v[v < 0] <- -v[v < 0] #cambio de elementos negativos a su correspondiente positivo

3.2.2 #Matrices y data frames

(mt <- matrix(11:30, nrow = 4, ncol = 5))

[Link] <- [Link](mt) #convierte matriz a un data frame
rownames([Link]) <- c("uno", "dos", "tres", "cuatro") colnames([Link]) <- c("UNO", "DOS", "TRES",
"CUATRO", "CINCO") [Link] #asignan nombres a renglones y columnas de [Link] #

[Link] El operador con un solo índice

mt[5] #matriz con índice 5
[Link][5] #data frame con índice 5

[Link] Omisión de índices en el operador

mt[3, ] # Selecciona de una matriz el tercer renglón
[Link][3, ] # Selecciona de un data frame el tercer renglón
mt[, 3] # Selecciona de una matriz la tercera columna
[Link][, 3] # Selecciona de un data frame la tercera columna
class(mt[3, ]) #
class([Link][3, ]) # sólo en este caso se cumple
class(mt[, 3])
class([Link][, 3])
mt[3, , drop = FALSE] # El tercer renglón
class(mt[3, , drop = FALSE])
[Link][3, , drop = FALSE]
class([Link][3, , drop = FALSE])
mt[, 3, drop = FALSE] #La tercer columna
class(mt[, 3, drop = FALSE])
[Link][, 3, drop = FALSE]
class([Link][, 3, drop = FALSE])
mt[, 4:2] # Selección de las columnas 4,3,2, en ese orden
[Link][, 4:2]
mt[1:3, 4:2]
[Link][1:3, 4:2]
[Link]. El uso de índices lógicos o condiciones
mt[2, ] #Selecciona de una matriz la segunda fila
[Link][2, ] #Selecciona de un data frame la segunda fila
mt[, 2] == 16 # De la columna 2 identifica el valor 16
[Link][, 2] == 16
mt[(mt[, 2] == 16), ] # Se usan paréntesis, (), para enfatizar la condición, aunque se los
puede omitir
[Link][([Link][, 2] == 16), ]
mt[(mt[, 2] == 16), , drop = FALSE] #obtiene una matriz (de un solo renglón)
mt[4, 2] <- 16L [Link][4, 2] <- 16L #obtiene más de un renglón que cumpla la condición
mt[(mt[, 2] == 16), ] #obtiene un conjunto de renglones
[Link][([Link][, 2] == 16), ]
mt[2, ]%%8 != 0 #obtiene todas las columnas que en su renglón 2 no son múltiplos de 8 #
operador módulo o residuo: %%
mt[, (mt[2, ]%%8 != 0)] #expresión como índice
[Link][, ([Link][2, ]%%8 != 0)]

3.3. Los operadores [[]] y $

rownames(mt)<-c( “uno”, “dos”, “tres”, “cuatro”)

colnames(mt) <-c(“UNO”, “DOS”, “TRES”, “CUATRO”, “CINCO”)
mt

mt[,”TRES”]
## uno dos tres cuatro
## 19 20 21 22
[Link][,”TRES”]
## [1] 19 20 21 22
mt[“dos”,]

## UNO DOS TRES CUATRO CINCO

## 12 16 20 24 28

df [“dos”, ]

## UNO DOS TRES CUATRO CINCO

## 12 16 20 24 28
[Link] [“dos”, ]

## UNO DOS TRES CUATRO CINCO

## dos 12 16 20 24 28

#para comparaciones con el operador [[]]

mt[“dos”, “TRES”, drop=F]

## TRES
## dos 20

Class(mt[“dos”, “TRES”, drop =F]) # La clase de objeto

## [1] “matrix”
[Link][“dos”, “TRES”, drop =F] # F es lo mismo que FALSE

## TRES
## dos 20

class([Link][“dos”, “TRES”, drop = F]) # La clase del objeto

## [1] “[Link]”

mt[[2, 3]]

## [1] 20

mt[[“dos”, “TRES”]]

## [1] 20

class(mt[[“dos”, “TRES”]])

## [1] “integer”

[Link][[2, 3]]

## [1] 20
class([Link][[2, 3]])

## [1] “integer”

[Link][[“dos”, “TRES”]]

## [1] 20
[Link][[“tres”]]

## [1] 19 20 21 22

[Link]$TRES

## [1] 19 20 21 22

[Link]$”TRES”

## [1] 19 20 21 22

[Link]$T

## [1] 19 20 21 22

[Link][[“TR”, exact = F]] # Recuerde F es FALSE

## [1] 19 20 21 22

Paul (64-78)
############################################
#4 ESTRUCTURA DE CONTROL Y MANEJO DE DATOS #
############################################

################################
# 4.1. Construcciones IF- ELSE #
################################

aa<-25.5 #Aquí se asigna una variable

if(aa<26) #If sin else
print ("SI MAYOR") #Establecer condición de mayor
if(aa<26)print("SI MAYOR") #Instrucción simple
if(aa<26){ #Instrucción compuesta
print("PRIMER RENGLON")
print("SI MAYOR")
}

#Empleando el valor que regresa el if

y<-1
y<-if(aa<26)50 #Prueba como si fuera verdadero o falso
y

#La construccion if admite una expresión que puede ser compuesta.

#En los casos anteriores, la expresión señalada por el if se ejecuta u omite
#dependiendo del valor de la condición, TRUE o FALSE, respectivamente.
#La siguientes construcciones, redirigen la ejecución del código a distintos bloques
#o conjuntos de instrucciones dependiendo de que se cumplan o no las condiciones
establecidas:
aa=8.5
if(aa<5) {
print("REMEDIAL")
} else if (5<=aa && aa<=6.99){
print("EXAMEN")
print("SUPLETORIO")
} else {
print("APROBADO")
}

#################
#4.2. LOS CICLOS#
#################

#Tipos de ciclo: repeticiones por un número determinado de veces, repeticiones mientras se

cumple
#una condición y repeticiones infinitas.

#########################################################################
###
#4.2.1. Repeticiones por un número determinado de veces: con la instrucción for
#FORMA 1
letras<-c("B", "i", "O", "q", "U","í", "M", "i", "C", "a")
letras
for(i in 1:10){
print(letras[i])
}

#FORMA 2: Con seq along

for(i in seq_along(letras)){
print(letras[i])
}

#FORMA 3
for (termino in letras){
print(termino)
}
#########################################################################
###
#4.2.2. Repeticiones mientras se cumple una condición: instrucción while
i<- 4
while (i<=10){
print(letras[i])
i<-i+1
}
#########################################################################
###
#4.2.3. Repeticiones infinitas: instrucción repeat
i<-4
repeat{
print(letras[i])
i<-i+1
if(i>10)
break
}
#########################################################################
###
#4.2.4. Interrupciones del flujo normal de ciclos
#Ejemplo 1: con números aleatorios
[Link](140)
aprox<-0.003
Y_ini<-2.7
for(iter in 1:1000){
Y<-Y_ini+0.008*rnorm(1)
if(abs(Y-Y_ini)<=aprox)
break
Y_ini<-Y
}
paste0("Y_ini: ", Y_ini, ", Y:", Y, ", Num. iter:", iter)

#Ejemplo 2: funcion con repetición

fibbonacci <- function(n) {
if (n %in% c(0,1))
return (1)
F0 <- 1; F1 <- 1; i <- 2
repeat {
s <- F0 + F1
if (i == n)
return (s)
F0 <- F1
F1 <- s
i <- i+1
}
}
fibbonacci (4)

#Ejemplo 3
for (i in 1:7){
if(3<=i && i<=5)
next
 print(i)
}

#########################################################################
##
## 4.3. Funciones de clasificación, transformación y agregación de datos ##
#########################################################################
##

#####################
# 4.3.1. Motivación #
#####################

#Programa para determinar el módulo de un vector n-dimensional

vv <- c(2,1,-2,5) #Se define el vector
modulo <- function (v){ #Se construye la función encargada de la operación
s <- 0 #Contiene la suma de cuadrados
for (elt_v in v){
s <- s + elt_v^2 #Incrementamos la suma
}
sqrt(s) #El módulo es la raíz de la suma
}

modulo(vv) #Resultado

#########################################################################
####
#Programa para calcular la media de un conjunto de datos
nums <- runif(32, 10.5, 40.8)
suma <-0
for (elt in nums){
suma <- suma + elt
}
(promedio <- suma/length(nums))
#########################################################################
#####
#Alternativas
(promedio <- sum(nums)/length(nums))

haz_promedio <- function (v){

sum(v)/length(v)
}
haz_promedio(nums)

mean(nums)
#########################################################################
#####
#Primer uso de la función Reduce
miSum <- function(v) Reduce("+",v)
miProd <-function (v) Reduce ("*",v)

prod(vv)
miProd (vv)
miSum(vv)
#########################################################################
#####
#Segundo uso de la función Reduce
mif <- function (a,b){
return (a*b/(a+b))
}
mi0p <- function (v) Reduce (mif,v)
mi0p(vv)

miOpV2 <- function(v) Reduce(function(a, b) a * b/(a + b), v,

accumulate = TRUE)
miOpV2(vv)

##############################################
# 4.3.2. Las funciones sapply () y lapply () #
##############################################
#La función sapply permite aplicar una operación o una función a cada uno
#de los elementos de la lista o data frame
(misDatos <- [Link] (uno = runif(5,10.5,40.3), dos = runif (5), tres = runif (5,155,890)))
sapply(misDatos, haz_promedio, simplify = TRUE)

#La función lapply permite aplicar operación o función y arrojar los resultados
#en una lista
lapply (misDatos, mean)

r <- numeric () #vector numerico para resultados

for (elt in misDatos){
r <- c(r, haz_promedio(elt))
}
names (r) <- names(misDatos)
r
###################################################################
# 4.3.3. Operaciones marginales en matrices y la función apply () #
###################################################################
(mm <- rbind(5:9, runif(5,10,20), c(2, -2, 1, 6,-8)))
colSums(mm) #Sumar todos los elementos de cada una de las columnas
rowMeans(mm) #Encontrar la media de cada una de las filas
apply(mm,1,sd) # el 1 es el margen: renglones
apply(mm,2,sd) # el 2 es el margen: columnas

ff <- function (v) v*(1:length(v))

ff(c(2,4,6,8))

apply(mm,2,ff)

######################################################
# 4.3.4. Clasificaciones y uso de la función split() #
######################################################
#Con esta función, puede escogerse los elementos de determinada fila o
#columnas y luego organizarlas dependiendo de otro parámetro
tt <- [Link](Estacion = c("E1", "E1", "E1", "E1", "E2", "E2", "E2","E3", "E3", "E3", "E3"),
Anio = c(1978, 1979, 1980, 1982, 1979, 1980, 1981, 1979, 1980, 1981, 1982), Enero = c(54,
21.5, 81, 37.5, NA, 105.2, 60.3, 10.8, 10.1, 20.2, 20.3),Febrero = c(38.5, 21, 31, NA, NA,
17.5, 3.2, 30.3, NA, 40.4, 50.5), Marzo = c(NA, 38.5, 4, 30, 155, 246, 100, 60.6, 70.6, 80.6,
90.6))
mls <- split (tt[,3:5],tt$Anio)
mls

Laura (79-93)
Kelly (94-108)
Fulton (109-124)

hist(pp$Precip, freq=F, breaks=15,

col="blueviolet", # Color de las barras
density=30, # Densidad de sombreado de las barras
main="Histograma y densidad Gamma", # Título
xlab="precipitacion (mm)", # Etiqueta del eje X
ylab="Densidad") # Etiqueta del eje Y

curve(dgammaX, add=T,
col="green", # Color de la curva
lwd=3) # Ancho de línea de la curva
plot(pp$Precip) # Produce un gráfico de "dispersión"
# Para el manejo de etiquetas especiales,
# con caracteres "raros para el Inglés",
lab <- "Años" # Etiqueta para las abscisas
plot([Link](rownames(pp)), # las abscisas
pp$Precip, # las ordenadas
type="l", # tipo de grafico: líneas
col="blue", # color: azul
main="Precipitaciones, Octubre", # Título
sub="Estado de Guerrero", # Subtítulo
xlab=lab, # etiqueta eje X
ylab="Precipitacion") # etiqueta eje Y
radio <- 0:10 # Vector de radios
area <- pi*radio^2 # Vector de áreas
tit <- "Áreas de círculos" # Título del gráfico
plot(radio, area, # x=radio y=area
type="b", # "both", puntos y líneas
main=tit,
xlab="Radio (r)",
ylab=expression(Area == pi*r^2), # Una expresión
col="orange", # color (naranja)
pch=20) # tipo de símbolo para punto
aa <- "área" # Texto para leyenda
pp <- "perímetro" # Texto para leyenca
xl <- "área, perímetro" # Etiqueta eje X
radio <- seq(0,5,by=0.5) # Vector de radios
area <- pi*radio^2 # Vector de áreas
perimetro <- 2*pi*radio # Vector de perímetros
plot(area, radio, type="o", xlab=xl, pch=21, col="red3",
bg="gold")
# En seguida "encimaremos" sobre el gráfico anterior (áreas),
# el de perímetros
lines(perimetro, radio, type="o", pch=23, col="navyblue",
bg="violetred")
legend("bottomright", # ubicación leyenda
legend = c(aa, pp ), # textos de leyenda
lty = c(1, 1 ), # tipo de línea
pch = c(21, 23 ), # símbolos
col = c("red3", "navyblue" ), # color líneas
[Link] = c("gold", "violetred") ) # relleno de símbolo
rgb(176, 48, 96, maxColorValue=255)
## [1] "#B03060"
# O como números entre 0 y 1 (porcentajes):
rgb(176/255, 48/255, 96/255)
## [1] "#B03060"
# La función rgb() puede producir los códigos
# de color de varios colores simultáneamente:
colores <- rgb(red= c(176,255,238,205),
green=c( 48, 52, 48, 41),
blue= c( 96,179,167,144),
max=255) # se puede abreviar "maxColorValue"
colores
## [1] "#B03060" "#FF34B3" "#EE30A7" "#CD2990"
plot(1:4, pch=22, cex=10, bg=colores,
xlim=c(-0.5,4.5), ylim=c(-0.5,4.5))
Los primeros veinte nombres de colores:
head(colors(),20)
## [1] "white" "aliceblue" "antiquewhite"
## [4] "antiquewhite1" "antiquewhite2" "antiquewhite3"
## [7] "antiquewhite4" "aquamarine" "aquamarine1"
## [10] "aquamarine2" "aquamarine3" "aquamarine4"
## [13] "azure" "azure1" "azure2"
## [16] "azure3" "azure4" "beige"
## [19] "bisque" "bisque1"
# Los elementos 455 al 458
coloresPorNombre <- colors()[455:458]
coloresPorNombre
## [1] "maroon" "maroon1" "maroon2" "maroon3"
# Para encontrar los contenidos de RGB:
(dd <- col2rgb(coloresPorNombre))
## [,1] [,2] [,3] [,4]
## red 176 255 238 205
## green 48 52 48 41
## blue 96 179 167 144
# Y para encontrar los hexadecimales correspondientes:
codigos <- rgb(red= dd["red",],
green=dd["green",],
blue= dd["blue",],
max=255) # se puede abreviar "maxColorValue"
codigos
## [1] "#B03060" "#FF34B3" "#EE30A7" "#CD2990"
# Pero, dado que 'dd' es una matriz,
# podemos obtener el mismo resultado con su
# traspuesta así:
(codigos <- rgb(t(dd), max=255))
## [1] "#B03060" "#FF34B3" "#EE30A7" "#CD2990"
# Se proporciona el vector de nombres de
# colores en vez del vector de códigos
plot(1:4, pch=22, cex=10, bg=coloresPorNombre,
xlim=c(-0.5,4.5), ylim=c(-0.5,4.5))
# la paleta actual
palette()
## [1] "black" "red" "green3" "blue" "cyan"
## [6] "magenta" "yellow" "gray"
# para cambiarla, por ejemplo, con los primeros
# veinticinco colores de colors()
palette(colors()[1:25])
# Se establece el espacio de dibujo:
plot(0, type="n", xlim=c(0,10), ylim=c(0,10))
# Se dibujan las líneas rectas; para ello,
# se hace uso de mapply que aplica de manera
# multiple una función:
void <- mapply(abline,
c(2,1,0,-1,-2), # interceptos por línea
rep(1,5)) # pendiente = 1
Laura (79-93)
Kelly (94-108)
Fulton (109-124)
mu <- mean(pp$Precip) # media
## [1] 115.5
sigma <- sd(pp$Precip) # desviación estándar
## [1] 56.01

#en R, la función de densidad normal de probabilidades es dnorm()

valores <- c(20,50,115,150,200) #precipitaciones

dnorm(valores,mu,sigma)
##[1] 0.001666 0.003597 0.007155 0.005890 0.002281

## Como μ y ౮ no varian para un conjunto de observaciones dado, se convierte en funcion.

dnormX <- function(x) dnorm(x,mu, sigma)

dnormX(valores)
##[1] 0.001666 0.003597 0.007155 0.005890 0.002281

##La funcion curve() sirve para graficar una funcion de densidad normal de probabilidades.

Lims <- c(mu-3*sigma,mu+3*sigma)

curve(dnormX,xlim=lims)

# Nótese que ahora los límites: lims, se imponen a la primer

# gráfica que se produce, en este caso, al histograma.
hist(pp$Precip, breaks = 15, freq = FALSE, xlim = lims)
# En lo que sigue, el argumento add=TRUE, indica que la curva
# se agrega al gráfico anterior
curve(dnormX, add = TRUE)

################5.5.5. Implementacion del metodo en R######################

#se debe instalar un paquete llamado numDeriv.

[Link](“numDeriv”)
#para usar el paquete se debe ordenar a R activarlo aplicando el comando
library(numDeriv)

#Traduccion de una funcion en codigo R:

miFun<- function(p) c(p[1]^2+p[1]*p[2]-100,p[1]+3*p[1]*p[2]^2-57)
p_tst <-c(1.5,3.5)
miFun(p_tst)
##[1] -2.500 1.625

#Ahora se puede aplicar el jacobiano de la funcion anterior evaluada en el mismo punto

jacobian(miFun,p_tst)

incremento<- solve(jacobian(miFun, p_tst),-miFun(p_tst))

incremento
## [1] 0.5360 -0.6561
siguiente_p <-p_tst + incremento
Siguiente
## [1] 2.036 2.844

#para para que el procedimiento sea general, la función podrá ser cualquiera que
represente un sistema de m ecuaciones no lineales, con m incógnitas

sigDx <- funcrion(ff,x){solve(jacobian(ff,x),-ff(x))}

siguiente_p <- p_tst + sigDx(miFun, P_tst))
## [1] 2.036 2.844

# Función para cálculo del módulo o magnitud de un vector

modulus <- function(x) sqrt(sum(x^2))
NwtRph <- function(ff, x0, eps=0.0001, lim=500, absComp=F) {
n <- 0 # número de iteración
repeat { # repetición infinita
difx <- sigDx(ff, x0) # diferencia de la sig. aprox.
x <- x0 + difx # la siguiente aproximación
# Hacemos el módulo de la diferencia para checar
r <- modulus(difx) # distancia entre x y x0
# Comparación absoluta o relativa
if (absComp) { # <-absoluta
if (r <= eps) return(x)
} else { # <-relativa
if (r <= eps*modulus(x0)) return(x)}
# si llega al máximo de iteraciones
# salimos con null
if (n > lim) return (NULL)
n <- n+1
x0 <- x # para la siguiente iteración}}
# Apliquemos para nuestro ejemplo, tomando
# p_tst, como valor inicial:
p <- NwtRph(miFun, p_tst)
print(p) # <- SOLUCIÓN
## [1] 2 3

#############5.5.6. Ajuste a la funcion de densidad de probabilidades#############

#Se realizara el ajuste usando la funcion Gamma de densidad de probabilidad.

mu<- mean(pp$Precip)
## [1] 115.5 #media
vz<-var(pp$Precip)
##[1] 3137 #varianza

#Traducir el codigo de la función vectorial F(p)

miFun <-function(p) c(p[1]*p[2]-mu,p[1]*p[2]^2-vz)

#si se considera como una aproximacion de (5,10) se aplica la funcion NwtRph()

p0<- c(5,10)
p<-NwtRph(miFun,p0)
print(p)
## [1] 4.25 27.17

dgammaX <-function(x) dgamma(x, shape=[1], scale=p[2])

# y se grafica.

hist(pp$Precip, breaks=15, freq=FALSE)

curve(dgammaX, add=TRUE)

#hay disponible una biblioteca, denominada “MASS” , que, entre otras operaciones, permite
#ajustar un conjunto de datos a una función de distribución cualquiera usando el método de
#máxima verosimilitud

[Link](“MASS”)

#Para utilizar la lectura MASS se debe usar la activacion.

library (MASS)

ff<-fitdistr(pp$Precip, dgamma, start=list(shape=p0[1],scale=p0[2]))

ff
## shape scale
## 4.1128 28.0696
## (0.8725) (6.3318)

#se elaborará también una función particular, como se hizo para el método anterior, que
#pueda ser graficada mediante la función curve(), de la siguiente manera

dgammaXX <- function(x) {dgamma(x, shape=ff$estimate[[1]], scale=ff$estimate[[2]])}

curve(dgammaX, col="green", lwd=2,
ylab="Densidad",
ylim=c(0,0.012), # Límites de Y
xlim=c(0,max(pp$Precip))) # Límites de X
curve(dgammaXX, col="red", lwd=2, add=T)

legend("topright",c("Metodo parametros", "Metodo max simil"),lwd=2, col=c("green", "red"))

#########################################################################
#############################CAPITULO 6##################################
#########################GRAFICACION CON R#############################
#########################################################################

#############################6.1 MOTIVACION##############################

hist(pp$Precip, freq=F, breaks=15,

col="blueviolet", # Color de las barras
density=30, # Densidad de sombreado de las barras
main="Histograma y densidad Gamma", # Título
xlab="precipitacion (mm)", # Etiqueta del eje X
ylab="Densidad") # Etiqueta del eje Y