OPERACIONES ARITMÉTICAS Y ESTADÍSTICAS

CON VECTORES, SELECCIÓN DE ELEMENTOS,

OPERACIONES LÓGICAS, FACTORES Y
VECTORES ALEATORIOS
César Anderson Huamaní Ninahuanca
Universidad Nacional del Centro del Perú
pe.cesar.huamani.n@uni.pe

10 de Enero del 2020

Al igual que las operaciones aritméticas, las operaciones a nivel vectorial también son importantes. En este
documento se mostrarán las operaciones más fundamentales.

OPERACIONES CON VECTORES.

Operaciones Aritméticas.

En el siguiente tabla se mostrarán las operaciones básicas que se pueden hacer con vectores.

OPERACIONES SINTAXIS
Adición +
Sustracción -
Producto Escalar %*%
Producto de Elementos *
Suma de elementos sum()

Para mostrar las operaciones primero se definirán 2 vectores que nos permitirán hacer los cálculos.
# Creamos el vector x
x<-1:8
x

## [1] 1 2 3 4 5 6 7 8
# Por último el vector y
y<-seq(3,27, length.out = 8)
y

## [1] 3.000000 6.428571 9.857143 13.285714 16.714286 20.142857 23.571429

## [8] 27.000000
Si no comprendió como se crearon estos vectores se recomienda revisar el siguiente enlace en donde se
muestra como se realizaron estas operaciones.
Si se toma en cuenta la adición, esta se dará entre los elementos de posiciones iguales. Es decir, se sumará
elemento de la primera posición del vector x y el elemento de primera posición del vector y, y así sucesivamente.
z<-x+y # Adición de vectores.
z

1
## [1] 4.000000 8.428571 12.857143 17.285714 21.714286 26.142857 30.571429
## [8] 35.000000
Para el caso de la sustracción es similar. Como se muestra en el siguiente ejemplo:
z1<-x-y # Sustracción de vectores.
z1

## [1] -2.000000 -4.428571 -6.857143 -9.285714 -11.714286 -14.142857

## [7] -16.571429 -19.000000
EL producto escalar, como se sabe es la suma agregada del producto de cada elemento de posiciones iguales.
Para poder determinarlo se usará el comando %*%.
z2<- x%*%y # Producto escalar.
z2

## [,1]
## [1,] 684
Si aún no lo ha comprendido en los siguientes ejemplos se verá cómo se calculo gracias al producto de
elementos y la suma de elementos..
El producto de elementos se da cuando se multiplica elementos de la misma posición:
z3<- x*y # Producto de Elementos.
z3

## [1] 3.00000 12.85714 29.57143 53.14286 83.57143 120.85714 165.00000

## [8] 216.00000
Para la suma de elementos se tendrá que usar el comando sum(), lo que hace es sumar todos los elementos
del vector.
z4<-sum(x) # Suma de elementos del vector.
z4

## [1] 36
Si nosotros queremos calcular el producto escalar se podría hacer usando el producto de elementos y la suma
de elementos.
producto.escalar<-sum(x*y)
producto.escalar

## [1] 684
El resultado es igual al del comando del producto escalar.
z2==producto.escalar

## [,1]
## [1,] TRUE
Adicionalmente podemos calcular la norma o longitud del vector como:
norma<-sqrt(sum(x^2))
norma

## [1] 14.28286
Para el caso del producto vectorial recién se podrá realizar en los siguientes documentos una vez concluido
el tema de matrices y bucles (especificamente, while).

2
Operaciones estadísticas.

A continuación se presentarán los comandos para realizar operaciones estadísticas con vectores.

OPERACIÓN SINTAXIS
Media mean()
Mediana median()
Máximo max()
Mínimo min()
Cuantiles quantile()
Producto prod()
Suma Acumulada cumsum()
Producto Acumulado cumprod()
Diferencias diff()
Coeficiente de Correlación cor()

Todas las operaciones se harán respecto al vector x.

Si se desea calcular la media aritmética o promedio de los elementos del vector, se tendrá que usar el comando
mean(), como sigue:
x

## [1] 1 2 3 4 5 6 7 8
e<-mean(x) # Cálculo de la media del vector x.
e

## [1] 4.5
Si no se contase con el operador median(), para hallar la mediana se tendría que ordenar ascendentemente
los elementos del vector y escoger el elemento que se encuentre en el medio. Pero gracias a éste comando, se
omite tal procedimiento.
e1<-median(x) # Cálculo de la mediana del vector x.
e1

## [1] 4.5
Para hallar el máximo elemento se usará el comando max().
e2<-max(x) # El elemento máximo del vector x.
e2

## [1] 8
Para calcular el mínimo elemento se usará el comando min()
e3<-min(x) # El elemento mínimo del vector x.
e3

## [1] 1
Para calcular los cuantiles se usará el comando quantile()
e4<-quantile(x)
e4

## 0% 25% 50% 75% 100%

## 1.00 2.75 4.50 6.25 8.00

3
Que nos arroja el primer, segundo y tercer cuartial que son de 2.75, 4.5, 6.25 respecivamente.
En el caso que se desee calcular el producto de los elemenos de x, se usará el comando prod()
e5<-prod(x) # EL producto de los elementos de x.
e5

## [1] 40320
Uno de las operaciones más importantes es la suma acumulada de elementos, para ello se usa el comando
cumsum(), lo que hace es sumar los dos primeros elemento; este resultado lo suma al tercer elemento y así
sucesivamente.
e6<-cumsum(x) # Suma acumulada de elementos de x.
e6

## [1] 1 3 6 10 15 21 28 36
Como se puede observar, el último elemento de la suma acumulada es igual a la suma de todos los elementos,
el resultado que se obtuvo con el comando sum().
Similarmente el producto acumulado:
e7<-cumprod(x) # El producto acumulado de elementos de x.
e7

## [1] 1 2 6 24 120 720 5040 40320

Para diferenciar elemento a elemento se usa el comando diff()realiza la diferencia entre dos elementos
contiguos.
e8<-diff(x) # Diferencias sucesivas de elementos de x.
e8

## [1] 1 1 1 1 1 1 1
Como el vector x es una secuencia que aumenta de 1 en 1. Al aplicar este comando el resultado nos muestra
que cada elemento del vector se diferencia en una unidad.
Por último, el coeficiente de corrrelación entre dos vectores.
e9<-cor(x,y) # El coeficiente de correlación entre x and y.
e9

## [1] 1
Para este caso el coeficiente de correlación de Sperman es de 1.

PARA ORDENAR ELEMENTOS DEL VECTOR.

Si deseamos ordenar los elementos del vector se usará los comandos sort() y rev().
Para lo cual definiremos al vector t:
t<-c(1,3,4,2,10,7,5,18,6)

Si deseamos ordenar los elementos del vector de manera creciente.

t_a<-sort(t) # Para ordenar los elementos ascendentemente.
t_a

## [1] 1 2 3 4 5 6 7 10 18
Si deseamos ordenar el vector de manera decreciente.

4
t_d<-sort(t, decreasing = TRUE) # Para ordenar los elementos descendentemente.
t_d

## [1] 18 10 7 6 5 4 3 2 1
Por último, si se desea invertir el orden de los elementos del vector.
t_i<-rev(t) # Para invertir el orden de los elementos.
t_i

## [1] 6 18 5 7 10 2 4 3 1

GRÁFICA DE OPERACIONES ENTRE VECTORES.

Como motivación se desarrollarán la gráfica para la suma de vectores de dimensión 2, por el método del
paralelogramo. Aún no hemos realizado la guía de gráficos pero esto será un adelanto de lo que se podrá ver
en siguientes guías. Así que si no comprende no se preocupe, más adelante se desarrollará a fondo.
Definimos los dos vectores con los que trabajaremos:
m<-c(3,8)
m

## [1] 3 8
p<-c(10,2)
p

## [1] 10 2
Si desarrollamos la suma de vectores:
a<-m+p
a

## [1] 13 10
Para poder graficarlo, la sintaxis es la siguiente:
# Para graficar el primer vector (vector m):
plot(3,8, xlim=c(0,14), ylim=c(0,12), xlab="Eje x", ylab="Eje y", lwd=3, col="blue"
, bty="n")
axis(side = 1, 0:14)
axis(side = 2, 0:12)
arrows(0,0,3,8,col="blue")
abline(h = pretty(0:12, 12), v = pretty(0:14, 14), col = "lightgray")

# Para graficar el segundo vector (vector p):

points(10,2,lwd=3,col="green")
arrows(0,0,10,2,col="green")

# Para graficar el vector resultante de la adición de los 2 vectores (a=m+p)

points(13,10,lwd=3,col="black")
arrows(0,0,13,10,col="black")

# Agregando las líneas imaginarias par formar el paralelogramo que representa

la adición de 2 vectores.
arrows(3,8,13,10,col="blue",lty=3)
arrows(10,2,13,10,col="green",lty=3)

5
 12
10
8
Eje y

6
4
2
0

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Eje x

La siguiente guía tratará sobre las selección de elementos y operadores lógicos aplicado a vectores.

6
 SELECCIÓN DE ELEMENTOS Y OPERACIONES LÓGICAS

En esta guía se desarrollará la selección de elementos de un vector, también la comprobación si elementos o

sub conjuntos pertenecen al vector. Así mismo se desarrollarán los operadores lógicos y por último la edición
individual o conjunta de elementos del vector.

SELECCIÓN DE ELEMENTOS.

Lo primero que se hará es definir el vector con el que se trabajará:

x<-c(2,1,3,12,43,43,6,8,62,9,0,5,23,42,4,1,3)
x

## [1] 2 1 3 12 43 43 6 8 62 9 0 5 23 42 4 1 3
Para poder seleccionar un elemento se usará el comando []. Dentro de el se colocará la posición del elemento
(puede ser un vector, incluso). Para mostrarlo a continuación unos ejemplos:
x[4] # Para seleccionar el cuarto elemento.

## [1] 12
Al colocar 4 dentro de los corchetes [] le indicamos que nos muestre el elemento de posición 4 del vector x.
Que para el caso es el valor de 12.
Un ejemplo adicional para que quede claro:
x[12] # Para seleccionar el duodécimo elemento.

## [1] 5
Pero como se indicó no sólo se puede colocar números dentro de los corchetes, sino que también se pueden
colocar vectores. En el siguiente ejemplo se muestra:
x[3:6] # Para seleccionar los elementos desde la tercera a la sexta posición.

## [1] 3 12 43 43
Pero si se desea excluir sólo a un elemento y que el resto de elementos se muestren se tendría que usar el -.
De la siguiente manera:
x[-2] # Para seleccionar todos los elementos menos el segundo.

## [1] 2 3 12 43 43 6 8 62 9 0 5 23 42 4 1 3
Al igual que antes también se puede especificar con un vector:
x[-(3:6)] # Todos los elementos excepto desde el tercero al sexto.

## [1] 2 1 6 8 62 9 0 5 23 42 4 1 3
Por último, a mi parecer, uno de los más importantes comandos (porque se usa en varias aplicaciones)
length(). Este comando nos indica el tamaño del vector.
length(x) # Indica el tamaño del vector.

## [1] 17
Como se puede observar el tamaño del vector es de 17, es decir, tiene 17 elementos.
Entonces, si usamos la sintaxis x[length(x)] nos mostrará el último elemento, ya que length(x) es igual a
17.

7
x[length(x)] # Para seleccionar el último elemento.

## [1] 3
Si usted desearía seleccionar el penúltimo elemento sólo tendría que considerar x[length(x)-1].

OPERADORES LÓGICOS.

Al igual que las operaciones aritméticas, las operaciones lógicas tienen una importancia primordial ya que a
través de ellas se pueden formar condicionales que nos simplificarán el procesamiento de datos.
En la siguiente tabla se muestra los operadores lógicos más importantes:

OPERADOR LÓGICO SINTAXIS

Igualdad ==
Mayor que >
Menor que <
Mayor igual que >=
Menor igual que <=
Diferente !=
Negación !
y &
o |

A continuación se mostrarán ejemplos para todos los casos:

Se continuará usando el vector x, para el caso de igualdad:
x[x==3] # Elementos iguales a 3.

## [1] 3 3
x[x==17] # Elementos iguales a 17.

## numeric(0)
En el primer caso lo que se indica es que muestre o seleccione los elementos que son iguales a 3 del vector
x. En el segundo ejemplo, lo mismo pero ahora los que son iguales a 17. Como se puede ver no existe
ningún elemento que sea 17 en el vector x por lo que se muestra ## numeric(0), que indica que no existe un
elemento con el valor de 17.
Para el caso del operador “mayor que”:
x[x>3] # Elementos mayores que 3.

## [1] 12 43 43 6 8 62 9 5 23 42 4
x[x>100] # Elementos mayores que 100.

## numeric(0)
Al igual que antes se observa el resultado de ## numeric(0), ya que, no existen elementos que sean mayores
que 100.
Si se desea usar el operador “menor que”:
x[x<5] # Elementos menores que 5.

8
## [1] 2 1 3 0 4 1 3
Aquí muestra todos los elementos que son menores que 5.
En los casos de “mayor igual que” y “menor igual que”, es previsible su uso.
# Mayor igual que ">=".

x[x>=8] # Elementos mayores iguales que 8.

## [1] 12 43 43 8 62 9 23 42
# Menor igual que "<=".

x[x<=8] # Elementos menores iguales que 8.

## [1] 2 1 3 6 8 0 5 4 1 3
Si se desea seleccionar los elementos que sean diferentes a un determinado valor se tendrá que usar el comando
!=.
x[x!=3] # Elementos diferentes de 3.

## [1] 2 1 12 43 43 6 8 62 9 0 5 23 42 4 1
Que muestra todos los elementos que son distintos de 3.
Para el caso de la negación:
x[!x<5] # Elementos que no son menores que 5.

## [1] 12 43 43 6 8 62 9 5 23 42
Aquí se especifica que se muestre los elementos que “no” son menores que 5. Fíjese en el símbolo ! que está
antes del signo <. Si usa el comando en sentido inverso le saldrá error.
Los siguientes operadores lógicos son los más importantes a la hora de desarrollar condicionales. Es preferible
repasarlos para un mejor entendimiento.
El operador lógico & lo que hace es unir dos o más operados lógicos y mostrará como resultado el valor o
valores “si y sólo si” se cumplen las dos pruebas lógicas.
x[x>3 & x<10] # Elementos mayores que 3 y menores que 10.

## [1] 6 8 9 5 4
En este caso, muestra los elementos que son mayores que 3 y a la vez que sean menores que 10.
Para el caso del operador lógico | une también dos o más operadores lógicos, pero que mostrará como resultado
el valor o valores si se cumple “una o las dos condiciones” por separado, es decir, estas condiciones no se
interponen entre sí.
x[x>3 | x<10] # Elementos mayores que 3 o menores que 10.

## [1] 2 1 3 12 43 43 6 8 62 9 0 5 23 42 4 1 3
En este ejemplo, se muestran todos los valores mayores que 3 y a la vez los menores que 10; por eso es
que valores como 2 que viola la primera prueba lógica pero cumple la segunda prueba se muestra (no se
interponen las pruebas).
Para que quede más claro, observe el siguiente ejemplo. En el que se indica que muestre los elementos
diferentes de 0 (sólo un elemento no cumple esa prueba, el cero) y que además sean mayores que 5 (los
elementos 1,2,3,4 no cumplen esta prueba, pero si la prueba anterior).

9
x[x!=0 | x>5] # Elementos diferentes de 0 o mayores que 5.

## [1] 2 1 3 12 43 43 6 8 62 9 5 23 42 4 1 3
Al final, el resultado es todos los números excepto el cero, ya que no cumple con ninguna de las dos pruebas
por separado.
Con los ejemplos anteriores se puede determinar que elemento(s) pertenecen al vector (siempre y cuando se
cumplan determinadas pruebas), pero si uno desea saber la posición de este(os) elemento(s), con lo hecho
anteriormente es imposible. Por tanto se tendrá que profundizar un poco más, en la siguiente sección se
muestra cómo.

¿CÓMO SABER LA POSICIÓN DE LOS ELEMENTOS DEL VECTOR?

Para responder esta pregunta se usará el comando which(). Al igual que antes dentro, del paréntesis tendrá
que digitar la prueba lógica.
A continuación unos ejemplos:
which(x==3) # En que posiciones se encuentra el elemento 3.

## [1] 3 17
Con el comando which() y la prueba lógica se pidió que se muestre la posición de los elementos del vector x
que sean iguales a 3. Este elemento está en la posición 3 y 17.
Un ejemplo adicional, para aclarar dudas.
which(x!=3 & x<5) # En que posición se encuentran los elementos diferentes de 3 y menores que 5.

## [1] 1 2 11 15 16
En este ejemplo se muestran los resultados de las posiciones de los elementos 0,1,2 y 4.

EDICIÓN INDIVIDUAL O CONJUNTA DE ELEMENTOS.

Para ver un poco más claro las posiciones del vector. Usaremos el comando View() que nos mostrará al
vector en formato tabla.
View(x)

10
 Figure 1: El vector x en formato tabla

Aquí nos podemos dar cuenta que a la posición 5 le corresponde el elemento de valor 43. Si nosotros
desearíamos cambiarlo por el de 33 usaríamos la siguiente sintaxis. En donde primero se especificaría la
posición deseada y luego colocar el símbolo <- que nos sirve para definir un vector o elemento (también se
podría usar =, pruebe y vea que resulta).
x[5]<-33 # Para cambiar el valor del elemento de la posición quinta.
x

## [1] 2 1 3 12 33 43 6 8 62 9 0 5 23 42 4 1 3
En efecto, el elemento de posición 5 ahora vale 33.
Si se da el caso de querer cambiar a varios elementos, podría usar la sintaxis siguiente:
x[c(1,5)]=x[c(1,5)]+5 # Para sumarle el valor de 5 a los elementos de las posicione 1 y 5.
x

## [1] 7 1 3 12 38 43 6 8 62 9 0 5 23 42 4 1 3
Lo que se hizo es sumarle 5 al primer y quinto elemento. Pero porque usar doble vez x[c(1,5)], en la
primera para indicar las posiciones y en la segunda para indicar que a esas posiciones le sumes 5. Si sólo se
pondría 5 sin el x[c(1,5)] cambiarías esas posiciones por 5.
Como usted se ha podido dar cuenta para la edición también se puede usar subvectores, incluso puede usar el
comando which().
Para muestra un ejemplo.

11
x[which(x==3)]=x[which(x==3)]+100
x

## [1] 7 1 103 12 38 43 6 8 62 9 0 5 23 42 4 1 103

En este caso sumamos 100 a las posiciones de los elementos iguales a 3 (posición 3 y 17, como se mostró
anteriormente).
Como comentario final, espero haya entendido la diferencia entre = y ==. Cualquier duda puede dejar su
comentario o escribirnos al correo.

12
 FACTORES: CODIFICACIÓN DE VARIABLES.

Convertir los elementos de un vector en factores permite una mejor presentación de los resultados, aunque
limita la operacionalización de este vector. Por eso se recomienda que este procedimiento se realice al final,
siempre y cuando, se tenga que hacer operaciones con los elementos del vector.

FACTORES

Usted cuando realiza una encuesta y pregunta sobre el género, a los encuestados, ellos responden entre
masculino y femenino. Pero para que usted lo procese, ya sea en una tabla o un gráfico, lo codifica como
números. Ejemplo 1 para masculino y 2 para femenino.
Eso es lo que hace el comando factor(), codifica los elementos del vector para colocarles etiquetas que se
convertirán en niveles.
A continuación se muestra un ejemplo similar.
#El vector de género de un salón:

g<-c(1,2,1,2,2,2,2,1,2,1,2,1,
2,1,2,1,1,2,1,2,1,1,1,2,2) # Vector de 1 y 2 que representan el género.

# Como quedó el vector que creamos:

g

## [1] 1 2 1 2 2 2 2 1 2 1 2 1 2 1 2 1 1 2 1 2 1 1 1 2 2
Usted se puede dar cuenta que el vector esta compuesto de unos y dos. Pero si realizas una tabla (se
desarrollará una guía completa en próximas presentaciones, aquí sólo se usa en el nivel más básico. Su
comando es table()) de estos datos se vería nada presentable:
table(g)

## g
## 1 2
## 12 13
Por tanto, es primordial el uso de factores.
El comando factor() tiene la siguiente sintaxis:
factor("Vector", "levels =", "labels =")
Donde Vector será el vector que se deseará convertir en factor, levels son los niveles en donde se
especificarán los valores numéricos que tomará el factor, y por último, labels es en donde se especifica las
etiquetas de los niveles.
Para poder comprenderlo, convertiremos en factor el vector g.
genero<-factor(g,
levels = c(1,2),
labels = c("Masculino", "Femenino"))

Como se puede observar se especificó el vector g, los niveles son 1 y 2 y las etiquetas son Masculino y
Femenino.
Los resultados se muestran a continuación:
genero

13
## [1] Masculino Femenino Masculino Femenino Femenino Femenino Femenino
## [8] Masculino Femenino Masculino Femenino Masculino Femenino Masculino
## [15] Femenino Masculino Masculino Femenino Masculino Femenino Masculino
## [22] Masculino Masculino Femenino Femenino
## Levels: Masculino Femenino
En efecto, se ha creado el vector genero que pasó de ser unos y dos para convertirse en masculino y femenino.
En la última salida, de estos resultados, se puede observar los niveles que han sido convertidos en Masculino
y Femenino.
Si ahora realizamos el comando table() otra vez. Los resultados serán más presentables.
table(genero)

## genero
## Masculino Femenino
## 12 13
Pero si usted desea agregar más niveles al ejemplo anterior sólo tendría que agregar en levels y en labels.
Hagamos un ejemplo, en el caso de agregar un nuenvo género, por ejemplo, los “medios”. La codificación
sería la siguiente:
n.genero<-factor(g,
levels = c(1,2,3),
labels = c("Masculino", "Femenino", "Medios"))

Si se ha podido dar cuenta, se agregó un nivel más, el nivel 3 y el label Medios. Veamos como quedan los
resultados.
n.genero # El factor n.genero

## [1] Masculino Femenino Masculino Femenino Femenino Femenino Femenino

## [8] Masculino Femenino Masculino Femenino Masculino Femenino Masculino
## [15] Femenino Masculino Masculino Femenino Masculino Femenino Masculino
## [22] Masculino Masculino Femenino Femenino
## Levels: Masculino Femenino Medios
# La tabla de n.genero
table(n.genero)

## n.genero
## Masculino Femenino Medios
## 12 13 0
Como se puede ver, ningún elemento de n.genero toma el valor de Medios, ya que el vector g no tenía el
elemento 3. Pero si se muestra en los labels, asi que si se modifica el vector g y se agrega elementos con
valor 3, se podrá ver elementos que tomen la etiqueta Medios.
Algo interesante de esto y que otros programas no lo hacen es mostrar los elementos nulos de un etiqueta.Es
decir, en la tabla se muestra que se tiene 0 Medios.
Ahora se realizará un nuevo ejemplo pero con una base de datos más real.

Usando base de datos real.

Cargaremos la base de datos de la Enaho, pero sólo la columna de nivel educativo (Hasta ahora no hemos
visto como agregar base de datos, así que si no comprende como cargarlo no se preocupe, haremos una guía
completa en próximas ediciones).

14
 Figure 2: Vista de la Base de Datos

Usted puede descargar esta base de datos del siguiente enlace.

base<-read.csv("F:/educ.csv", header = TRUE)

Veamos como esta compuesta esta base de datos.

View(base)

Como se puede observar (en la figura 1) es la pregunta p109a de la encuesta ENAHO, que tiene 15621
elementos.
Veamos una tabla de esta base de datos.
table(base)

## base
## 1 2 3 4 5 6 7 8 9 10
## 560 273 1750 1195 1995 4983 543 1376 1055 1891

15
 Figure 3: Vista de la Base de Datos Codificada.

El resultado es nada claro, lo que tenemos que hacer es convertir a este vector en factor. Realizaremos este
procedimiento, en el siguiente código.
base$p109a<-factor(base$p109a,
levels = 1:10,
labels = c("Sin Nivel","Inicial","Primaria Incompleta",
"Primaria Completa","Secundaria Incompleta",
"Secundaria Completa","S.NU. Incompleta",
"S.NU. Completa","S.U. Incompleta",
"S.U. Completa"))

Primero especificamos el vector que es base$p109a (porque: la base de datos es base pero el vector es
p109a, no puedo llamar defrente al vector -escribir p109a-1 ya que es parte de la base de datos. Para llamar
al vector se tiene que usar el comando $, lo que se ha hecho es decir de la base de datos base selecciona con
$ el vector p109a), los niveles son 10, por eso se especifica 1:10 y las etiquetas son las que se muestran.
Veamos como quedo nuestra base de datos:
View(base)

Como se puede observar (en la figura 2) todo a quedado codificado y se muestran las etiquetas.
Por último realizaremos una tabla con estos niveles.
1 Para omitir el comando $ se usa attach a la base de datos con lo cual sólo se podría usar el nombre del vector. Para adjuntar

la base de datos se tendría que usar de esta manera attach(base). En la guía de data frame se verá con mayor claridad esto.

16
table(base)

## base
## Sin Nivel Inicial Primaria Incompleta
## 560 273 1750
## Primaria Completa Secundaria Incompleta Secundaria Completa
## 1195 1995 4983
## S.NU. Incompleta S.NU. Completa S.U. Incompleta
## 543 1376 1055
## S.U. Completa
## 1891
¿Aún le parece poco presentable esta tabla? La respuesta más segura es que si. El detalle es que R tiene una
interfaz muy sencilla y nada amigable. Pero esto es un punto a favor, ya que, esto permite que la tabla que
se generó se pueda exportar en distintos formatos como latex, html, doc, xlsx, entre otros.
En guías posteriores usted verá el potencial de esto, por el momento es prematuro avanzar en lo que concierne
a tablas. Aún hay comandos que se tienen que apreender ya que estos nos servirán para llegar a niveles
deseados.

17
 CREACIÓN DE ELEMENTOS DE MANERA ALEATORIA

En esta guía tratará de como crear una muestra aleatoria con el comando sample, esto es muy útil si se desea
realizar rifas, sorteos, entre otros. Lo que realiza es de un vector universal escoger otro vector en donde los
elementos han sido escogidos aleatoriamente.

CREAR ELEMENTOS DE MANERA ALEATORIA.

Para esto usaremos el comando sample que tiene la siguiente sintaxis.

sample("vector",size ="#", replace="T o F", prob="vector")
Donde sample es el comando para generar una muestra de manera aleatoria; vector es el vector en donde
se encuentra el universo de elementos; en size irá el tamaño del vector, es decir, la cantidad de elementos
deseados; replace es un argumento lógico en donde puede ir TRUE o FALSE, si es el primero le estaremos
diciendo a R que para la selección de elementos se de con reemplazo caso contrario no se permitirá el
reemplazo (el valor por defecto es FALSE); por útlimo, prob es el argumento que indica la probabilidad de
ocurrencia de los elementos del vector universal.
Pero como se está escogiendo aleatoriamente cada vez que se corra el código se crearán vectores diferentes.
Por tanto para que la aleatorización de elementos sea reproducible se usará el comando set.seed(), con este
comando podremos reproducir los resultados obtenidos en cualquier momento.
A continuación unos ejemplos.
Si deseamos obtener de manera aleatoria un vector de elementos 1 y 2 y que tenga 20 elementos.
set.seed(1)
x<-sample(c(1,2), size = 20, replace = TRUE) # Vector de 20 elementos
x

## [1] 1 1 2 2 1 2 2 2 2 1 1 1 2 1 2 1 2 2 1 2
Como se puede observar primero definimos la semilla set.seed(1) esto para que al correr una y otra vez
el mismo código nos resulte el mismo resultado. Posteriormente se ha generado el vector x de 1 y 2 como
elementos, en donde se indica que el tamaño sea de 20 elementos (size=20), además se considera que se
escoga con reemplazo. La cantidad de 1 y 2 resultante es aleatoria. Para ver la proporción usamos el comando
fdt, pero primero se tendrá que instalar el paquete "fdth"
# Para instalar el paquete fdth.
install.packages("fdth")

Y cargamos el paquete:
library(fdth)

Ahora podremos usar el comando fdt para conocer las frecuencia de los elementos.
freq1<-fdt(x, k=2)
freq1

## Class limits f rf rf(%) cf cf(%)

## [0.99,1.5) 9 0.45 45 9 45
## [1.5,2) 11 0.55 55 20 100
De los 20 elementos se generaron 9 unos y 11 dos (esto se ve en la salida f) lo que da que la frecuencia relativa
sea de 45% para el elemento 1 y 55% para el elemento 2 (esto se ve en la salida rf). Como se escoge de
manera aleatoria esta proporción a la larga llevará a que la cantidad de 1 y 2 sea del 50% para cada elemento,
esto es lo que indica la ley de grandes números. Veamos si se cumple tal afirmación.

18
set.seed(2)
x1<-sample(c(1,2), size = 100, replace = T) # Vector de 100 elementos.
x2<-sample(c(1,2), size = 1000, replace = T) # Vector de 1000 elementos.
x3<-sample(c(1,2), size = 100000, replace = T) # Vector de 100000 elementos.
x4<-sample(c(1,2), size = 1000000, replace = T) # Vector de un millón de elementos.

Mostraremos los resultados en tablas de frecuencias:

freqx1<-fdt(x1,k=2)
freqx2<-fdt(x2,k=2)
freqx3<-fdt(x3,k=2)
freqx4<-fdt(x4,k=2)
freqx1; freqx2; freqx3; freqx4

## Class limits f rf rf(%) cf cf(%)

## [0.99,1.5) 55 0.55 55 55 55
## [1.5,2) 45 0.45 45 100 100
## Class limits f rf rf(%) cf cf(%)
## [0.99,1.5) 497 0.5 49.7 497 49.7
## [1.5,2) 503 0.5 50.3 1000 100.0
## Class limits f rf rf(%) cf cf(%)
## [0.99,1.5) 49698 0.5 49.7 49698 49.7
## [1.5,2) 50302 0.5 50.3 100000 100.0
## Class limits f rf rf(%) cf cf(%)
## [0.99,1.5) 499555 0.5 49.96 499555 49.96
## [1.5,2) 500445 0.5 50.04 1000000 100.00
En efecto, como se puede observar, a mayor cantidad de elementos las distribuciones se acercan al 50%.
Cuando se le indicó a R que realice una muestra de un millón de elementos las frecuencias relativas fueron de
49.96% para 1 y 50.04% para 2 (esto se ve en la salida rf(%)).
Pero nosotros podemos controlar las probabilidades de ocurrencia. Para esto, indicaremos la probabilidad
con el argumento prob.
Si deseamos que la probabilidad de ocurrencia del elemento 1 sea del 20% y del elemento 2 sea del 80% (no
necesariamente los porcentajes deben de sumar 100%).
# 1 con 20% de probabilidad y 2 con 80% de probabilidad.
set.seed(3)
x5<-sample(1:2, size = 20, replace = TRUE, prob = c(0.2,0.8))
x5

## [1] 2 1 2 2 2 2 2 2 2 2 2 2 2 2 1 1 2 2 1 2
En el argumento prob = c(0.2,0.8) es donde se indica que 1 tenga una probabilidad de ocurrencia de 20%
y 2 de 80%.
Lo mostraremos en una tabla de frecuencias:
freqx5<-fdt(x5, k=2)
freqx5

## Class limits f rf rf(%) cf cf(%)

## [0.99,1.5) 4 0.2 20 4 20
## [1.5,2) 16 0.8 80 20 100

19
En efecto, se mantiene la probabilidad de ocurrencia señalada (Las frecuencias relativas indican 20% para 1 y
80% para 2). Es curioso que en este ejemplo nos haya resultado con 20% y 80% en las frecuencias relativas,
esto no sucede comunmente, si usted desea vuelva a correr este código sin la semilla y verá que el resultado
es distinto. Es decir, para este ejemplo se tuvo un chispazo de buena suerte.
A continuación se muestra un ejemplo para un vector caracter.
set.seed(4)
x6<-sample(c("Masculino","Femenino"), size = 30, replace = TRUE)
x6

## [1] "Femenino" "Masculino" "Masculino" "Masculino" "Femenino"

## [6] "Masculino" "Femenino" "Femenino" "Femenino" "Masculino"
## [11] "Femenino" "Masculino" "Masculino" "Femenino" "Masculino"
## [16] "Masculino" "Femenino" "Femenino" "Femenino" "Femenino"
## [21] "Femenino" "Femenino" "Femenino" "Masculino" "Femenino"
## [26] "Femenino" "Masculino" "Femenino" "Femenino" "Femenino"
Los códigos indicaron a R que seleccione una muestra de 30 elementos entre Masculino y Femenino con
reemplazo.
Para verlo mejor lo presentamos en una tabla:
table(x6)

## x6
## Femenino Masculino
## 19 11
Se escogió una muestra con 19 Femeninos y 11 Masculinos.

Recordad:

• El comando set.sed() puede tomar como semilla cualquier número.

• Si usted usa una semilla determinada y realiza con esa semilla otra simulación, los resultados que se
obtendrán serán iguales.
Para muestra el siguiente ejemplo:
# Usamos la semilla 1.
set.seed(1)
z<-sample(c("Lunes", "Martes"), size = 20, replace = T)
table(z)

## z
## Lunes Martes
## 9 11
como se observa Lunes se escogió 9 veces y Martes 11 veces (En el ejemplo de 1 y 2; con la semilla set.seed(1)
los resultados fueron 9 veces 1 y 11 veces 2).
• Por tanto, es recomandable no usar semillas iguales.
En la siguiente guía se verá el tema de data frame.

20