1. Fundamentos del programa

1.1 ¿Qué es R?

1.1.1 Introducción a R

R es un lenguaje y entorno de computación estadística que es un proyecto GNU, similar al lenguaje S desarrollado en Bell Laboratories. R es altamente extensible y ofrece una amplia gama de técnicas estadísticas y gráficas. Es conocido por su facilidad para crear gráficos de alta calidad y está disponible como software libre bajo la licencia pública general GNU. Puede ejecutarse en diversas plataformas, incluyendo UNIX, Windows y MacOS.

1.1.2 El entorno R

R es un conjunto integrado de funciones de software para manipulación de datos, cálculos, visualización gráfica y análisis estadístico. Proporciona herramientas para el tratamiento de datos, operaciones con matrices, análisis de datos, visualización gráfica, y un lenguaje de programación eficaz. A diferencia de otros programas de análisis de datos, R se caracteriza por ser un sistema planificado y coherente. Permite a los usuarios agregar funcionalidad adicional definiendo nuevas funciones y puede vincularse con código C, C++, y Fortran para tareas computacionalmente intensivas. Además, cuenta con una amplia gama de paquetes que amplían sus capacidades en estadísticas modernas y ofrece documentación completa en varios formatos.

1.2 ¿Qué es IDE - RStudio?

Un IDE nos proporciona herramientas para escribir y revisar nuestro código, administrar los archivos que estamos usando, gestionar nuestro entorno de trabajo y algunas otras herramientas de productividad. Tareas que serían difíciles o tediosas de realizar de otro modo, son fáciles a través de un IDE. Este entorno, además de incorporar las funciones esenciales de una IDE, es desarrollado por un equipo que ha contribuido de manera significativa para lograr que R sea lenguaje de programación más accesible, con un énfasis en la colaboración y la reproducción de los análisis. Para instalar RStudio, es necesario con descargar y ejecutar alguno de los instaladores disponibles en su sitio oficial. Están disponibles versiones para Windows, OSX y Linux. https://www.rstudio.com/products/rstudio/download/

1.3 Programación orientada a objetos

La Programación Orientada a Objetos (POO) es un paradigma de programación, es decir, un modelo o un estilo de programación que nos da unas guías sobre cómo trabajar con él. Se basa en el concepto de clases y objetos. Este tipo de programación se utiliza para estructurar un programa de software en piezas simples y reutilizables de planos de código (clases) para crear instancias individuales de objetos.

La programación orientada a objetos en RStudio permite organizar y gestionar el código de una manera más eficiente, ya que los objetos pueden contener datos y métodos relacionados, lo que facilita el encapsulamiento y la reutilización del código. Esto es especialmente útil en aplicaciones de análisis de datos y estadísticas donde los datos y las operaciones sobre ellos suelen estar altamente interrelacionados.

2. Manipulación de objetos.

2.1 ¿Qué es la manipulación de objetos?

La manipulación de objetos en RStudio se refiere al proceso de crear, modificar, acceder y trabajar con objetos en el lenguaje de programación R dentro del entorno de desarrollo integrado RStudio. En R, los objetos pueden ser vectores, matrices, data frames, listas, funciones y más, y la manipulación de estos objetos es fundamental en tareas de análisis de datos y programación en general.

Algunas de las operaciones comunes de manipulación de objetos en RStudio incluyen:

Creación de objetoS

Puedes crear objetos asignando valores o estructuras de datos a nombres.

mi_vector <- c(1, 2, 3)
mi_vector

## [1] 1 2 3

Acceso a objetos:

Puedes acceder a elementos específicos de un objeto utilizando índices o nombres. Por ejemplo, para acceder al segundo elemento de un vector, puedes usar

mi_vector[2]

## [1] 2

Modificación de objetos:

Puedes modificar objetos existentes al cambiar los valores de sus elementos o al agregar o eliminar elementos. Por ejemplo, puedes modificar un valor en un vector con

mi_vector[1] <- 5
mi_vector

## [1] 5 2 3

Operaciones sobre objetos:

Puedes realizar operaciones matemáticas, estadísticas u otras operaciones en objetos para realizar cálculos y análisis de datos. Por ejemplo, puedes sumar dos vectores o calcular la media de un conjunto de datos.

Por ejemplo, creamos un vector numérico.

mi_vector <- c(2, 3, 6, 7, 8, 10, 11)
mi_vector

## [1]  2  3  6  7  8 10 11

mi_vector + 2

## [1]  4  5  8  9 10 12 13

mi_vector * 2

## [1]  4  6 12 14 16 20 22

mi_vector %% 2

## [1] 0 1 0 1 0 0 1

En RStudio, la manipulación de objetos es una parte fundamental del proceso de análisis de datos y programación, ya que te permite realizar operaciones, cálculos y transformaciones en los datos de manera efectiva.

2.2 Clases

En RStudio, las “clases” se refieren a las definiciones de tipos de objetos que permiten estructurar y organizar datos de manera más avanzada y específica. Las clases se utilizan en R para crear objetos que pueden contener datos y métodos específicos relacionados con esos datos.

Los tipos de objetos en R se conocen en la comunidad como clases. Existen muchas clases de objetos, pero las clases más sencillas son 5:

Tipo de dato	Descripcion	Ejemplo
Logical	verdadero/falso	TRUE, FALSE
numeric	números reales o decimales	2.3, pi, sqrt(2)
integer	números enteros	-5L, 2L, 8L
character	caracteres o cadenas de carateres	“hola mundo”
complex	números complejos	2.1 + 3i + 2i

2.2.1 Objetos

En RStudio, como en el lenguaje de programación R en general, los “objetos” se refieren a las estructuras de datos que almacenan información y que se utilizan en análisis de datos, cálculos y programación en general. Estos objetos pueden ser de diferentes tipos y se utilizan para representar datos y resultados de operaciones en R. Aquí hay algunos ejemplos comunes de objetos en RStudio:

2.2.2 Vectores

Los vectores son secuencias de elementos del mismo tipo, como números enteros, números decimales o caracteres. Pueden ser vectores numéricos, de caracteres o lógicos, entre otros.Un vector es la estructura de datos más sencilla en R.

Todos los vectores tienen tres propiedades:

1. Tipo

Un vector tiene el mismo tipo que los datos que contiene. Si tenemos un vector que contiene datos de tipo numérico, el vector será también de tipo numérico.

2. Largo

Es el número de elementos que contiene un vector.

3. Atributos

Los vectores pueden tener metadatos de muchos tipos, los cuales describen características de los datos que contienen.

Creacion de vectores

creacion usando c(): combina valores individuales

c(2,7,8,12,3,25)

## [1]  2  7  8 12  3 25

## function (...)  .Primitive("c")

y <- c(red="Bob", blue="Dave", green="Jenny")
y

##     red    blue   green 
##   "Bob"  "Dave" "Jenny"

Vectores con patrones

También existen vectores en los que sus elementos siguen cierto patrón:

Comando	Genera
rep( )	Repite elementos del vector
seq( )	Elementos ordenados en progresion aritmetica

Comando rep( )

Este comando tiene la siguiente sintaxis:

\[rep("elemento", "# de veces")\] A continuación se muestra unos ejemplos:

\[x1<-rep(2,5) # Para repetir 2 cinco veces.\]

## [1] 2 2 2 2 2

\[x2<-rep("Luis",10) # Para repetir "Luis" diez veces.\]

x2<-rep("Luis",10)
x2

##  [1] "Luis" "Luis" "Luis" "Luis" "Luis" "Luis" "Luis" "Luis" "Luis" "Luis"

Este comando también puede repetir vectores. Para lo cual usa la siguiente sintaxis:

\[rep(“vector", “time" or “each")\] La condición time se usa cuando se quiere repetir el vector un número determinado de veces y each cuando se requiere repetir los elementos del vector. A continuación se muestran unos ejemplos

rep(1:4, times=2, each=2)

##  [1] 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4

rep(4:5, 3)

## [1] 4 5 4 5 4 5

Comando seq( )

Este comando tiene como fin que los elementos del vector aumenten o decrezcan en proporción a una razón aritmética. La sintaxis es la siguiente:

\[seq(“inicio", “final", by=“razón")\]

Donde inicio corresponde al número con el que empezará la progresión, final indica el último número de la progresión y por último by= es el comando en donde se tendrá que indicar la razón aritmética. A continuación se muestra un ejemplo:

La progresión será creciente, ya que se tiene que considerar al elemento inicial 1 y al elemento final el 20 o algún número cercano a este (por la especificación de la razón aritmética).

v1<-seq(1, 20, by=2)

##  [1]  1  3  5  7  9 11 13 15 17 19

La progresión será decreciente, puesto que el número inicial es 40 y el final el número 3 o un número cercano.

v2<-seq(40, 3, by=-4)

##  [1] 40 36 32 28 24 20 16 12  8  4

Como se puede dar cuenta si el número inicial es mayor que el número final la razón tiene que ser negativa.

Por último, si deseamos tener una determinada dimensión y omitir la razón se considera la siguiente sintaxis:

\[seq(“inicio", “final", length.out=“n")\] Donde length.out indica la dimensión del vector.

El vector empezará de 1 y terminará en 50 y tendrá una dimensión de 10.

v3<-seq(1,50, length.out=10)
v3

##  [1]  1.000000  6.444444 11.888889 17.333333 22.777778 28.222222 33.666667
##  [8] 39.111111 44.555556 50.000000

Clases de vectores

En la siguiente tabla se muestran las clases de vectores que se pueden usar en R.

Clases de vector	contiene
Integer	Números enteros
Númeric	Números reales
Logical	Caracteres logicos
Character	Caracteres o palabras
Complex	Números complejos

Vector Integer - Números enteros.

Para la clase de vectores Integer sólo permite elementos que sean números enteros. En el entorno R para definir un número entero es necesario agregar al número la letra L, como se muestra a continuación:

x<-c(1L,2L,3L,4L,5L,6L)

y<-c(1L,3L,5L,7L,9L,11L,13L)

Se realizó la definición de los vectores x y y. En los cuales se hizo uso de <- y c. Los resultados se muestran a continuación:

## [1] 1 2 3 4 5 6

## [1]  1  3  5  7  9 11 13

Vector Numeric - Números reales.

Con respecto a la clase de vectores Numeric estos adminten números reales. Es muy fácil definirlos, a continuación se muestra un ejemplo.

z<-c(1.3, pi, exp(1))

t<-c(sin(pi/4), log(45), tan(pi/3))

Los vectores z y t contienen números reales, en el caso del vector z está compuesto por 1.3, pi y el número de euler. Los resultados son los siguientes:

## [1] 1.300000 3.141593 2.718282

## [1] 0.7071068 3.8066625 1.7320508

Vector Logical - Caracteres lógicos.

Para el caso de los vectores Logical sólo acepta como elementos a TRUE y FALSE. A continuación se muestra un ejemplo:

m<-c(TRUE,FALSE,FALSE,TRUE)

p<-c(T,F,F,T,T,T,F)

Como se habrán podido dar cuenta no es necesario escribir las palabras completas (TRUE y FALSE) es suficiente con escribir sus iniciales. Para comprobarlo a continuación se muestran los resultados.

## [1]  TRUE FALSE FALSE  TRUE

## [1]  TRUE FALSE FALSE  TRUE  TRUE  TRUE FALSE

Vector Character - Palabras.

Si se desea crear vectores Character se tendrá que usar como elementos sólo palabras o caracteres. Estos vendrán especificados por las comillas ““, un ejemplo se muestra a continuación:

p1<-c("Luis", "María", "José")

p2<-c("12", "casa", "pi")

El vector p1 contiene nombres (palabras) y el vector p2 contiene los números 12 y pi, pero como se usó las comillas R los considera como caracteres, adicionalmente tiene a la palabra casa.

## [1] "Luis"  "María" "José"

Vector Complex - Números complejos.

Por último, los vectores complex que tiene elementos que sólo son números complejos. Para definir un número complejo es necesario considerar el número imaginario i. A continuación se muestran uno ejemplo:

c1<-c(1+2i, 4i, 3+6i)

El vector c1 contiene tres elementos, los cuales son números omplejos. Los resultados son los siguientes:

## [1] 1+2i 0+4i 3+6i

¿Cómo saber si un objeto definido es un vector?

Para poder saber si un objeto definido es un vector, es necesario usar el comando is.vector( ). Este nos arrojará los valores TRUE (si es un vector) o FALSE (si no es un vector). Acontinuación se muestran los resultados para algunos de los vectores que hemos definido antes:

is.vector(x)

## [1] TRUE

is.vector(z)

## [1] TRUE

is.vector(p1)

## [1] TRUE

is.vector(c1)

## [1] TRUE

todas las variables definidas, resultan ser vectores.

¿Cómo saber de que clase es un vector?

Para conocer la clase, se tendrá que usar los comandos is.integer( ), is.numeric( ), is.logical( ), is.character( ) y is.complex( ). Al igual que antes este arrojará TRUE o FALSE. A continuación se muestran unos ejemplos.

is.integer(x)

## [1] TRUE

is.numeric(x)

## [1] TRUE

is.logical(m)

## [1] TRUE

is.character(p1)

## [1] TRUE

is.complex(p1)

## [1] FALSE

Puede parecer algo confuso, pero usted se puede preguntar, por qué el vector x que fue definido como Integer también arroja como si fuera un vector Numeric. Esto es porque los números enteros están contenidos en los números reales, mejor dicho el conjunto de números enteros es un subconjuto del conjunto de los números reales.

2.2.3 Matrices

Las matrices son objetos bidimensionales que contienen elementos del mismo tipo. Son útiles para representar datos tabulares y realizar cálculos matriciales.

Creación usando matrix(): se especifica filas y columnas

matrix(data = 1:6, nrow = 2, ncol = 3, byrow = FALSE)

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

matrix(1:6, 2, 3)

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

Creación usando dim(): establece la dimensión

x <- 1:6; dim(x) <- c(2, 3)
x

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

Creación usando cbind(), rbind(): combina filas o columnas

x <- c(1, 2, 3) 
y <- 10:12
cbind(x, y)

##      x  y
## [1,] 1 10
## [2,] 2 11
## [3,] 3 12

rbind(x, y)

##   [,1] [,2] [,3]
## x    1    2    3
## y   10   11   12

Se puede asignar nombres a las filas y columnas de una matriz

z <- matrix(1:6, 2, 3)
rownames(z) <- c("A", "B"); colnames(z) <- c("a", "b", "c ")
z

##   a b c 
## A 1 3  5
## B 2 4  6

Acceso a los datos:

z[2,3]; z[2, ]; z[ ,3]

## [1] 6

##  a  b c  
##  2  4  6

## A B 
## 5 6

2.2.4 Arreglos

En RStudio, los “arreglos” se refieren a estructuras de datos multidimensionales que almacenan valores en una cuadrícula de varias dimensiones. Los arreglos son una extensión de las matrices y los vectores en R, que son estructuras unidimensionales o bidimensionales.

Creación de arreglos:

Puedes crear arreglos en RStudio utilizando la función array( ). Esta función toma un vector de datos, así como argumentos adicionales que especifican las dimensiones del arreglo. Por ejemplo:

# Crear un arreglo tridimensional
arreglo_3d <- array(data = c(1, 2, 3, 4, 5, 6), dim = c(2, 3, 1))
arreglo_3d

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

Acceso a elementos:

Puedes acceder a elementos específicos de un arreglo utilizando índices en cada dimensión. Por ejemplo:

# Acceder al elemento en la primera fila, segunda columna y única "capa" del arreglo
elemento <- arreglo_3d[1, 2, 1]
elemento

## [1] 3

Los arreglos son útiles cuando necesitas manejar datos que tienen más de dos dimensiones, como datos tridimensionales en el caso de imágenes médicas o series temporales multivariadas. Puedes realizar operaciones matriciales y estadísticas en arreglos y acceder a elementos en función de sus coordenadas en múltiples dimensiones.

2.3 La indentación

La indentación, en programación, se refiere a la práctica de agregar espacios o tabulaciones al principio de las líneas de código. Esta técnica se utiliza para mejorar la legibilidad del código y delimitar visualmente los bloques y estructuras de control en un programa.

Agregar un espacio inicial (indentación) en las líneas de código resalta la jerarquía de las estructuras de control, como bucles, condicionales y funciones. Este enfoque facilita la comprensión de la estructura del programa y ayuda a evitar errores de lógica.

Conforme añadimos más líneas de código a nuestro programa, este se volverá más complejo, lo que aumentará el tiempo necesario para revisar y solucionar errores. Sin embargo, para agilizar la lectura y comprensión del código, es recomendable aplicar la técnica de indentación.

La indentación se logra mediante el uso de la barra espaciadora o la tecla de tabulación, y es una práctica común en programación. Es importante mantener la coherencia en el estilo de indentación dentro de un proyecto y seguir las pautas de estilo de la empresa u organización con la que colaboras.

Este es un ejemplo:

for (i in 1:5) {
  cat("Iteración ", i, "\n")
}

## Iteración  1 
## Iteración  2 
## Iteración  3 
## Iteración  4 
## Iteración  5

2.4 Expresiones Condicionales

2.4.1 If

La declaración “if” es una estructura de control utilizada para ejecutar un bloque de código en caso de que una condición sea verdadera. La sintaxis es la siguiente: if evalúa una expresión y, según su resultado (verdadero o falso), determina si se ejecuta el bloque de código que le sigue. Si la expresión es verdadera, se ejecuta el código; si es falsa, el programa continúa su flujo normal. La instrucción “if” es fundamental para tomar decisiones condicionales en tu código. Permite ejecutar un bloque de código si se cumple una condición específica y, de manera opcional, otro bloque de código si la condición no se cumple.

Este es un ejemplo:

edad <- 25

# Comprobamos si la edad es mayor o igual a 18
if (edad >= 18) {
  cat("Eres mayor de edad.\n")
} else {
  cat("Eres menor de edad.\n")
}

## Eres mayor de edad.

2.4.2 Else

La declaración “else” se combina con “if” para ejecutar un bloque de código si la condición “if” es falsa. Significa “de otro modo” y es usada para indicarle a R qué hacer en caso de la condición de un “if” no se cumpla.

Si no incluyes else, el programa simplemente no hará nada si la condición es falsa y continuará con el código que sigue.

temperatura <- 25

# Comprobamos si la temperatura es mayor o igual a 30
if (temperatura >= 30) {
  cat("Hace calor.\n")
} else {
  cat("No hace calor.\n")  # Este bloque se ejecuta cuando la condición es falsa
}

## No hace calor.

2.4.3 Else if

La declaración “else if” se utiliza para evaluar múltiples condiciones en secuencia. Si la primera condición es falsa, se verifica la siguiente condición y así sucesivamente. Úsala para especificar una nueva condición que se probará si la primera condición es falsa.

“Elseif” (también escrito como “else if”) es una estructura que se utiliza en combinación con la declaración “if” para manejar múltiples condiciones en una secuencia de decisiones. Permite evaluar varias condiciones secuencialmente y ejecutar un bloque de código en función de la primera condición que sea verdadera.

nota <- 75

# Comprobamos la nota y asignamos una calificación
if (nota >= 90) {
  cat("Tienes una A.\n")
} else if (nota >= 80) {
  cat("Tienes una B.\n")
} else if (nota >= 70) {
  cat("Tienes una C.\n")
} else if (nota >= 60) {
  cat("Tienes una D.\n")
} else {
  cat("Tienes una F.\n")
}

## Tienes una C.

2.4.4 Ifelse

La función ifelse se utiliza para realizar evaluaciones condicionales en vectores. Permite aplicar una condición a cada elemento de un vector y devolver un resultado en función de la condición. En lugar de escribir una línea de código para cada comparación, podemos usar una sola llamada a esta función, que se aplicará a todos los elementos de un vector.

Ifelse nos permite vectorizar if - else, devolviendo un valor para cada elemento de un vector en el que la condición sea TRUE, además de otro valor para los elementos en que la condición sea FALSE.

edades <- c(25, 18, 15, 30, 40)

# Usar ifelse para determinar si cada persona es mayor de edad
mayor_de_edad <- ifelse(edades >= 18, "Sí", "No")

# Imprimir los resultados de cada elemento del vector
cat("¿Es mayor de edad?\n")

## ¿Es mayor de edad?

cat(mayor_de_edad, "\n")

## Sí Sí No Sí Sí

Operadores lógicos:

2.4.4 Operador AND

El operador (& o &&) se utiliza para combinar dos condiciones o expresiones lógicas y devuelve TRUE solo si ambas condiciones son verdaderas. Si alguna de las condiciones es falsa, el resultado será FALSE.

Tenemos un ejemplo con variables logicas:

condicion1 <- TRUE
condicion2 <- FALSE

# Usamos el operador AND para verificar si ambas condiciones son verdaderas
resultado <- condicion1 & condicion2

# Imprimimos los resultados
cat("condicion1 es igual a TRUE\n")

## condicion1 es igual a TRUE

cat("condicion2 es igual a FALSE\n")

## condicion2 es igual a FALSE

cat("resultado es igual a", resultado, "\n")

## resultado es igual a FALSE

Tenemos un ejemplo con funciones condicionales:

edad <- 25
tiene_licencia <- TRUE

# Verificamos si la edad es mayor o igual a 18 y si tiene licencia de conducir
if (edad >= 18 & tiene_licencia) {
  cat("Puede conducir.\n")
} else {
  cat("No puede conducir.\n")
}

## Puede conducir.

2.4.5 Operador OR

Operador ( | o || ) se utiliza para combinar dos condiciones o expresiones lógicas y devuelve TRUE si al menos una de las condiciones es verdadera. Solo devolverá FALSE si ambas condiciones son falsas.

Tenemos un ejemplo con variables logicas:

condicion1 <- TRUE
condicion2 <- FALSE

# Usamos el operador OR para verificar si al menos una de las condiciones es verdadera
resultado <- condicion1 | condicion2
# Imprimimos los resultados
cat("condicion1 es igual a TRUE\n")

## condicion1 es igual a TRUE

cat("condicion2 es igual a FALSE\n")

## condicion2 es igual a FALSE

cat("resultado es igual a", resultado, "\n")

## resultado es igual a TRUE

Tenemos un ejemplo con funciones condicionales:

edad <- 20

# Verificamos si la edad es igual a 18 o 21
if (edad == 18 | edad == 21) {
  cat("La edad es igual a 18 o 21.\n")
} else {
  cat("La edad no es igual a 18 ni 21.\n")
}

## La edad no es igual a 18 ni 21.

2.4.6 Operador NOT

El operador (!) tiene la función de invertir el valor de verdad de una expresión lógica. Es decir, si una expresión es verdadera, el operador “!” la convierte en falsa, y si una expresión es falsa, el operador “!” la convierte en verdadera.

Tenemos un ejemplo con variables logicas:

es_falso <- FALSE

# Usamos el operador ! para invertir la condición
es_verdadero <- !es_falso

# Imprimimos los resultados
cat("es_falso es igual a FALSE\n")

## es_falso es igual a FALSE

cat("es_verdadero es igual a", es_verdadero, "\n")

## es_verdadero es igual a TRUE

Tenemos un ejemplo con funciones condicionales:

edad <- 25

# Verificamos si la edad no es igual a 18
if (!(edad == 18)) {
  cat("La edad no es igual a 18.\n")
} else {
  cat("La edad es igual a 18.\n")
}

## La edad no es igual a 18.

3. Bucles

3.1 ¿Qué es un bucle?

Los bucles, son una forma de declaración de control, simplifican la repetición de tareas o conjuntos de acciones. Son vitales tanto en programación como en la gestión de datos, ya que automatizan tareas repetitivas, aumentan la eficiencia y reducen errores. Al mismo tiempo, evitan la repetición innecesaria de instrucciones, contribuyendo a mantener el código limpio y fácil de gestionar.

Un bucle hace una consulta, en la estructura de bucle. Si la respuesta a esa consulta requiere una acción, se ejecutará. La misma consulta se realiza una y otra vez hasta que se toman medidas adicionales. Cada vez que se realiza la consulta en el ciclo, se conoce como una iteración del ciclo. Hay dos componentes de un ciclo, la instrucción de control y el cuerpo del ciclo. La sentencia de control controla la ejecución de sentencias dependiendo de la condición y el cuerpo del bucle consiste en el conjunto de sentencias a ejecutar.

Estos bucles se aplican en diversos contextos. En programación, se utilizan para repetir tareas. En el procesamiento de datos, facilitan la manipulación de grandes conjuntos de información. Además, encuentran utilidad en la simulación de sistemas, la automatización industrial y la administración de sistemas, así como en el desarrollo web para la presentación dinámica de datos y en el análisis estadístico y científico para realizar cálculos y análisis repetitivos. Su versatilidad los convierte en una herramienta esencial en diversas disciplinas laborales.

Es importante destacar que los bucles desempeñan un papel crítico en la gestión de grandes bases de datos, especialmente en la era de “big data” por su capacidad para procesar grandes conjuntos de datos de manera eficiente.

3.2 Construción de bucles

En RStudio, una “construcción de bucle” se refiere a la creación de un bucle, que es una estructura de control que permite ejecutar un conjunto de instrucciones repetidamente. Los bucles son útiles cuando deseas realizar una tarea o un conjunto de tareas de manera repetitiva, como iterar a través de elementos de una lista o realizar cálculos en una serie de datos.

En RStudio, puedes crear bucles utilizando principalmente dos tipos de estructuras de control de bucle: el bucle “for” y el bucle “while”. Aquí hay una breve descripción de ambos y como contruirlos apartir de una estructura:

3.3 Tipos de Bucles

3.3.1 Bucle FOR

El bucle for, también conocido como ciclo for, es una herramienta poderosa para iterar sobre secuencias, como números o elementos de un vector. Se utiliza para realizar tareas repetitivas, como cálculos de sumas o promedios y operaciones en listas, y se controla mediante una condición de prueba que determina si se ejecuta el cuerpo del bucle, si la condición de prueba es falsa, el cuerpo del bucle no se ejecutaría. . El bucle for es especialmente útil cuando se conoce el número de que queremos que se ejecute.

3.3.1.1 Su estructura es:

for (variable in secuencia) {
  # Código a ejecutar en cada iteración
}

Donde:

variable es una variable que toma el valor de cada elemento de la secuencia en cada iteración del bucle.
secuencia es una secuencia de valores o elementos sobre los cuales se realizará la iteración.
El código dentro del bucle for se ejecuta en cada iteración, y puedes utilizar la variable para acceder al valor actual de la iteración.

Tenemos un ejemplo:

for (i in 11:13) {
  cat("Tabla de multiplicar del", i, ":\n")
  for (j in 1:12) {
    resultado <- i * j
    cat(i, "x", j, "=", resultado, "\n")
  }
  cat("\n")
}

## Tabla de multiplicar del 11 :
## 11 x 1 = 11 
## 11 x 2 = 22 
## 11 x 3 = 33 
## 11 x 4 = 44 
## 11 x 5 = 55 
## 11 x 6 = 66 
## 11 x 7 = 77 
## 11 x 8 = 88 
## 11 x 9 = 99 
## 11 x 10 = 110 
## 11 x 11 = 121 
## 11 x 12 = 132 
## 
## Tabla de multiplicar del 12 :
## 12 x 1 = 12 
## 12 x 2 = 24 
## 12 x 3 = 36 
## 12 x 4 = 48 
## 12 x 5 = 60 
## 12 x 6 = 72 
## 12 x 7 = 84 
## 12 x 8 = 96 
## 12 x 9 = 108 
## 12 x 10 = 120 
## 12 x 11 = 132 
## 12 x 12 = 144 
## 
## Tabla de multiplicar del 13 :
## 13 x 1 = 13 
## 13 x 2 = 26 
## 13 x 3 = 39 
## 13 x 4 = 52 
## 13 x 5 = 65 
## 13 x 6 = 78 
## 13 x 7 = 91 
## 13 x 8 = 104 
## 13 x 9 = 117 
## 13 x 10 = 130 
## 13 x 11 = 143 
## 13 x 12 = 156

3.3.2 Bucle WHILE

El bucle while es una estructura de control que permite la repetición de un conjunto de instrucciones mientras se cumpla una condición específica. Su funcionamiento se basa en la evaluación de la condición antes de cada repetición. El factor clave se este bucles esta en que el bucle se ejecuta mientras una condición lógica sea verdadera (TRUE). Este tipo de bucle es valioso cuando no se conoce de antemano cuántas repeticiones serán necesarias.

A diferencia del bucle for, en el bucle while no se establece un número fijo de iteraciones. Se verifica la condición antes de cada iteración, y el código se ejecuta repetidamente mientras la condición sea verdadera. Es fundamental garantizar que la condición eventualmente se vuelva falsa para evitar bucles infinitos.

El bucle while es especialmente útil en estudios de simulación, donde se requiere que el código se ejecute hasta que se cumpla un criterio específico.

3.3.2.1 Su estructura es:

while (condición) {
  # Código a ejecutar mientras la condición sea verdadera
}

Donde:

condición es una expresión lógica que se evalúa en cada iteración del bucle. Mientras esta condición sea verdadera, el bucle continuará ejecutando el código.
El código dentro del bucle while se ejecuta en cada iteración siempre y cuando la condición sea verdadera.

Tenemos un ejemplo:

numero <- 3
i <- 1

cat("Tabla de multiplicar del", numero, ":\n")

## Tabla de multiplicar del 3 :

while (i <= 12) {
  resultado <- numero * i
  cat(numero, "x", i, "=", resultado, "\n")
  i <- i + 1
}

## 3 x 1 = 3 
## 3 x 2 = 6 
## 3 x 3 = 9 
## 3 x 4 = 12 
## 3 x 5 = 15 
## 3 x 6 = 18 
## 3 x 7 = 21 
## 3 x 8 = 24 
## 3 x 9 = 27 
## 3 x 10 = 30 
## 3 x 11 = 33 
## 3 x 12 = 36

3.4 Declaraciones de control

Las declaraciones o estructura de control son elementos esenciales en la programación que permiten dirigir y controlar el flujo de ejecución de un programa. Estas estructuras establecen condiciones y reglas para determinar cómo se ejecutan las operaciones y en qué orden. Son fundamentales para la lógica de un programa, especialmente al definir funciones.

Las estructuras de control más comunes en R son las siguientes:

Estas estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa según condiciones predefinidas, lo que otorga al programador un alto grado de flexibilidad en la programación.

Las estructuras de control se dividen en tres categorías: secuenciales, condicionales e iterativas. Las secuenciales representan la ejecución lineal de comandos, mientras que las condicionales permiten realizar acciones basadas en condiciones. Por otro lado, las estructuras iterativas posibilitan la repetición de un bloque de instrucciones un número de veces definido o mientras se cumple una condición.

1. Estructuras de control condicionales

Las estructuras de control condicionales son herramientas cruciales en la programación. Se utilizan cuando, en ciertas partes de un algoritmo, es necesario tomar decisiones basadas en una pregunta que puede tener respuestas verdaderas o falsas (TRUE o FALSE). Dependiendo de esta respuesta, el programa seguirá diferentes caminos, lo que permite adaptar la solución a diversas situaciones. Estas estructuras de control se conocen como condicionales o estructuras de selección y se dividen en tres tipos:

Estructuras condicionales simples

Las estructuras condicionales simples postulan una evaluación lógica y, si su resultado es TRUE, se procede a ejecutar las acciones encerradas por esta estructura.

Estructuras condicionales dobles

Este tipo de estructura añade una acción a ejecutarse en el caso de que la condición evaluada no se verifique (es decir, devuelve el valor FALSE).

Estructuras condicionales múltiples o anidadas

Permiten combinar varias estructuras condicionales para establecer controles más complejos sobre el flujo de las acciones, representando una toma de decisión múltiple.

2. Estructuras de control iterativas

Las estructuras de control iterativas son esenciales cuando se requiere que un conjunto de acciones se ejecute repetidamente para resolver un problema. El número de repeticiones puede ser fijo o variable, dependiendo de la información proporcionada en el algoritmo.

Estructuras de Control Iterativas con un Número Fijo de Iteraciones: Se utilizan cuando se conoce de antemano el número exacto de veces que se debe repetir una secuencia de acciones. Esto proporciona un control preciso sobre la cantidad de repeticiones.
Estructuras de Control Iterativas con un Número Indeterminado de Iteraciones: En algunas circunstancias, es necesario repetir un bloque de acciones sin conocer previamente cuántas veces se ejecutará. El número de iteraciones depende de ciertas condiciones o datos del algoritmo. En este tipo de estructuras, el conjunto de instrucciones se repite mientras una condición específica evaluada al inicio del bloque sigue siendo VERDADERA (TRUE). Cuando la condición ya no se cumple, el proceso de repetición se detiene.

Estas estructuras iterativas son vitales en la programación, ya que permiten realizar tareas repetitivas de manera eficiente y flexible, adaptándose a diferentes requerimientos y condiciones en la solución de problemas.

Las estructuras de control en R se resumen en la siguiente tabla:

# Crear una tabla de estructuras de control
control_estructuras <- data.frame(
  Estructura = c("if", "else if", "else", "switch", "for", "while", "repeat", "break", "next"),
  Descripción = c(
    "Toma decisiones basadas en una condición.",
    "Se utiliza junto con `if` para manejar múltiples condiciones en una estructura de control.",
    "Define un bloque de código que se ejecuta si la condición en `if` o `else if` es FALSA.",
    "Toma decisiones basadas en el valor de una expresión y ejecuta el código correspondiente al caso coincidente.",
    "Repite un bloque de código un número fijo de veces.",
    "Repite un bloque de código mientras una condición sea verdadera.",
    "Repite un bloque de código indefinidamente hasta que se encuentra una instrucción `break`.",
    "Sale de un bucle de repetición antes de que se cumpla la condición de salida normal.",
    "Omite la iteración actual de un bucle y pasa a la siguiente iteración."
  )
)

# Imprimir la tabla
knitr::kable(control_estructuras, caption = "Estructuras de Control en R")

Estructuras de Control en R
Estructura	Descripción
if	Toma decisiones basadas en una condición.
else if	Se utiliza junto con `if` para manejar múltiples condiciones en una estructura de control.
else	Define un bloque de código que se ejecuta si la condición en `if` o `else if` es FALSA.
switch	Toma decisiones basadas en el valor de una expresión y ejecuta el código correspondiente al caso coincidente.
for	Repite un bloque de código un número fijo de veces.
while	Repite un bloque de código mientras una condición sea verdadera.
repeat	Repite un bloque de código indefinidamente hasta que se encuentra una instrucción `break`.
break	Sale de un bucle de repetición antes de que se cumpla la condición de salida normal.
next	Omite la iteración actual de un bucle y pasa a la siguiente iteración.

4. Conclusión

En resumen, nuestro trabajo introduce a R como un lenguaje y entorno de computación estadística. Del trabajo concluimos la extensibilidad, amplia gama de técnicas estadísticas y facilidad para crear gráficos de alta calidad en R. Además, R es un software libre y puede ejecutarse en varias plataformas. Al explorar el entorno de R como un conjunto de funciones para manipulación de datos, cálculos, visualización gráfica y análisis estadístico, destacamos su capacidad para definir nuevas funciones y su compatibilidad con código en C, C++ y Fortran.

Vimos a RStudio como un entorno de desarrollo integrado (IDE) que facilita la escritura y revisión de código en R, así como la administración de archivos y la colaboración. Tambien, la programación orientada a objetos en RStudio y su utilidad para organizar y gestionar el código de manera eficiente.

Entendimos que la manipulación de objetos en RStudio se refiere a la creación, modificación y trabajo con objetos en R, como vectores, matrices y arreglos.

Notamos la importancia de la indentación en la programación como una práctica para mejorar la legibilidad del código y estructurar las estructuras de control. Aprendimos la función de los bucles en la programación, destacando su utilidad para automatizar tareas repetitivas y reducir errores, de los tipos de bucles, como for y while. Luego, utilizamos los operadores lógicos, como AND, OR y NOT, utilizados en R para combinar condiciones y tomar decisiones en estructuras condicionales.

Finalmente, de las estructuras de control condicionales en R, como if, else if, else y ifelse, junto con las estructuras de control iterativas, como for y while, concluimos que las condicionales en R sirven para tomar decisiones basadas en condiciones específicas, lo que permite que el programa ejecute diferentes acciones según los resultados de las evaluaciones lógicas. Por otro lado, las iterativas se utilizan para automatizar tareas repetitivas, permitiendo que un bloque de código se ejecute varias veces, lo que es esencial para procesar datos, realizar cálculos y análisis eficientes.

Este texto proporciona una visión general de las características y herramientas clave de R y RStudio, así como de las estructuras de control utilizadas en programación con R.

Autores:

Lorena Sofia Davila Anchivilca

Angela Maria Ortega Valera

Rstudio

LORENA DAVILA-ORTEGA ANGELA

2023-10-12

1. Fundamentos del programa

1.1 ¿Qué es R?

1.1.1 Introducción a R

1.1.2 El entorno R

1.2 ¿Qué es IDE - RStudio?

1.3 Programación orientada a objetos

2. Manipulación de objetos.

2.1 ¿Qué es la manipulación de objetos?

2.2 Clases

2.2.1 Objetos

2.2.2 Vectores

2.2.3 Matrices

2.2.4 Arreglos

2.3 La indentación

2.4 Expresiones Condicionales

2.4.1 If

2.4.2 Else

2.4.3 Else if

2.4.4 Ifelse

Operadores lógicos:

2.4.4 Operador AND

2.4.5 Operador OR

2.4.6 Operador NOT

3. Bucles

3.1 ¿Qué es un bucle?

3.2 Construción de bucles

3.3 Tipos de Bucles

3.3.1 Bucle FOR

3.3.1.1 Su estructura es:

3.3.2 Bucle WHILE

3.3.2.1 Su estructura es:

3.4 Declaraciones de control

1. Estructuras de control condicionales

2. Estructuras de control iterativas

4. Conclusión