1 Variables y Tipos

Una variable es un nombre que hace referencia a un valor. Una de las características más poderosas de un lenguaje de programación es la capacidad de manipular variables. Una variable es el nombre de una ubicación de memoria reservada que contiene algún valor.

Por ejemplo:

x = 50. Aquí, ‘x’ es el nombre de la variable, el signo igual (=) es un operador de asignación y 50 es el valor o literal. Otra forma de asignar es mediante ’<-’ .

Entonces, al usar un operador de asignación (= o <-), podemos reservar memoria para el valor sin declararlo explícitamente.

x=50
x<-50

1.1 Reglas para definir un nombre de variable

En el lenguaje de programación R, existen pautas que es necesario respetar al asignar nombres a las variables. Estas directrices garantizan que los nombres de las variables sean adecuados y que el código sea fácil de leer y mantener. A continuación, se presentan las principales pautas a seguir al definir nombres de variables en R:

Caracteres permitidos: Los nombres de variables en R pueden consistir en letras (mayúsculas y minúsculas), números y el símbolo de punto (.) o guión bajo (_). Los nombres de variables deben comenzar con una letra o un guión bajo. No se permiten otros caracteres especiales, como espacios, signos de puntuación o símbolos matemáticos.
Palabras reservadas: No debes utilizar palabras reservadas de R como nombres de variables, ya que estas palabras tienen un significado específico en el lenguaje y pueden causar conflictos. Algunos ejemplos de palabras clave reservadas son “if”, “else”, “for”, “while”, “function”, entre otras.
Mayúsculas y minúsculas: R es sensible a las mayúsculas y minúsculas, lo que significa que distingue entre letras mayúsculas y minúsculas en los nombres de las variables. Por lo tanto, las variables “miVariable” y “mivariable” se consideran diferentes.
Longitud: Los nombres de las variables pueden ser de cualquier longitud, pero es una buena práctica mantenerlos cortos y descriptivos para facilitar la legibilidad del código. Evita nombres excesivamente largos o crípticos.
Descripción clara: Es importante que los nombres de las variables sean descriptivos y reflejen el propósito de la variable en tu código. Esto ayuda a comprender rápidamente lo que hace una variable sin necesidad de comentarios adicionales.

1.2 Operadores aritméticos

Los operadores aritméticos son necesarios para realizar operaciones aritméticas como suma, resta, multiplicación, división, etc. La siguiente tabla es la lista de operadores aritméticos en R:

Nombre del operador	Simbolo del operador	Descripción	Ejemplo
suma	‘+’	Se utiliza para sumar dos valores.	x+y
resta	‘-’	Se utiliza para restar un valor de otro.	x-y
división	‘/’	Se utiliza para dividir un valor entre otro.	x/y
división entera	‘%/%’	Se utiliza para realizar una división entera, que devuelve el cociente de la división sin el residuo.	x%/%y
multiplicación	‘*’	Se utiliza para multiplicar dos valores.	x*y
módulo	‘%%’	Se utiliza para obtener el residuo de una división.	x%%y
potenciación	‘^ ó **’	Se utiliza para elevar un número a una potencia.	x^y ó x**y
raíz cuadrada	‘sqrt()’	La función sqrt() se utiliza para calcular la raíz cuadrada de un número.	sqrt(x)
valor absoluto	‘abs()’	La función abs() se utiliza para obtener el valor absoluto de un número.	abs(x)
redondeo	‘round()’	La función round() se utiliza para redondear un número al entero más cercano.	round(x)

Ejemplos:

x<-50
y<-8

# Suma
x+y

[1] 58

# Resta
x-y

[1] 42

# División
x/y

[1] 6.25

# División entera
y%/%x

[1] 0

# Multiplicación
x*y

[1] 400

# Raíz cuadrada
sqrt(x)

[1] 7.071068

# Valor absoluto
abs(y-x)

[1] 42

# Redondear
round(x/y)

[1] 6

1.3 Operadores relacionales

Los operadores relacionales se utilizan para comprobar la relación entre operandos y comparar los valores. Según la condición, estos operadores devuelven como resultado “Verdadero” o “Falso”:

Nombre del operador	Simbolo del operador	Descripción	Ejemplo
igualdad	==	Comprueba si dos valores son iguales.	x==y
desigualdad	!=	Comprueba si dos valores no son iguales.	x!=y
mayor que	>	Comprueba si un valor es mayor que otro.	x>y
menor que	<	Comprueba si un valor es menor que otro.	x<y
mayor o igual que	>=	Comprueba si un valor es mayor o igual que otro.	x>=y
menor o igual que	<=	Comprueba si un valor es menor o igual que otro.	x<=y

Ejemplos:

x<-16
y<-25

# Igualdad
x==y

[1] FALSE

# Desigualdad
x!=y

[1] TRUE

# Mayor que
x>y

[1] FALSE

# Mayor o igual que
x>=y

[1] FALSE

1.4 Operadores de asignación

Para asignar el valor a una variable, utilizamos operadores de asignación. La siguiente es una lista de operadores de asignación en R:

Nombre	Símbolo	Descripción	Ejemplo
Asignación clásica	<- o =	Estos operadores se utilizan para asignar un valor a una variable.	x <- 50
Asignación en lugar	<<-	Este operador se utiliza para asignar un valor a una variable que no está en el entorno actual, sino en un entorno superior (global).	y <<- 10

Ejemplos:

# Asignación clásica
x<-50

# Asignación en lugar
y<<-10

1.5 Operadores lógicos

En R, los operadores lógicos se utilizan para realizar operaciones de lógica booleana en expresiones que devuelven valores TRUE (verdadero) o FALSE (falso).

La siguiente tabla tiene la información completa sobre los operadores lógicos en R.

Nombre del operador	Simbolo del operador	Descripción
AND (y) lógico	& o &&	Da como resultado ‘TRUE’ si ambos operandos son ‘VERDADEROS’ y ‘FALSE’ en caso contrario.
OR (o) lógico	\| o \|\|	Da como resultado ‘TRUE’ si alguno de los operandos es ‘VERDADERO’ y ‘FALSE’ en caso contrario.
NOT (No) lógico	!	Da como resultado ‘TRUE’ si un operando es ‘FALSO’ y ‘FALSE’ si un operando es ‘VERDADERO’.

Ejemplos:

x<-TRUE
y<-TRUE

# Operador AND lógico
x&&y

[1] TRUE

# Operador OR lógico
x||y

[1] TRUE

# Operador NOT lógico
!x

[1] FALSE

1.6 Tipos de datos integrados en R

Existen numerosos tipos de datos en R que almacenan varios tipos de datos. Los cuatro tipos principales de datos que es más probable que se utilicen son: numéricos, de caracteres (string), Date/POSIXct (basado en tiempo) y lógicos (TRUE/FALSE).

El tipo de datos contenidos en una variable se verifica con la funcion de clase class()

Numérico:

Es el tipo de dato más común en R. La prueba de si una variable es numérica es mediante la funcion is.numeric() .
Un dato entero también es numérico, para comprobar si es entero se usa is.integer().
```
a <- 5L
b <- 10
is.integer(a)
```
```
[1] TRUE
```
```
is.numeric(a)
```
```
[1] TRUE
```
```
class(b)
```
```
[1] "numeric"
```
```
class(a)
```
```
[1] "integer"
```
```
class(a*b)
```
```
[1] "numeric"
```
Caracter (string):

Es muy común en el análisis estadístico y debe manejarse con cuidado. R tiene dos formas de manejar estos datos: character y factor .
```
x <- "data"
x
```
```
[1] "data"
```
```
y <- factor("data")
y
```
```
[1] data
Levels: data
```
Para hallar el largo de un caracter use la función nchar, esto no funcionará para factor.
```
nchar("Hola")
```
```
[1] 4
```
```
nchar(.314)
```
```
[1] 5
```
Fechas:

R tiene tipos diferentes de fechas. Los más útiles son Date y POSIXct. Date almacena solo una fecha mientras que POSIXct almacena una fecha y hora.
Ambos objetos se representan como el número de dias (Date) o segundos (POSIXct) desde el 1 de enero de 1970.
```
date1 <- as.Date("2023-09-28")
date1
```
```
[1] "2023-09-28"
```
```
date2 <- as.POSIXct("2023-09-28 15:23")
date2
```
```
[1] "2023-09-28 15:23:00 -05"
```
Lógicos:

Son una forma de representar datos que pueden ser TRUE o FALSE. Numéricamente, TRUE es lo mismo que 1 y FALSE es lo mismo que 0.
```
k <- TRUE
class(k)
```
```
[1] "logical"
```
```
FALSE*5
```
```
[1] 0
```
Son el resultado de comparar dos números o caracteres.
```
# ¿Es 2 igual a 3?
2==3
```
```
[1] FALSE
```
```
# ¿Es "data" menor que "stats"?
"data"<"stats"
```
```
[1] TRUE
```

1.7 Conversión de tipos de datos:

En R, puedes realizar conversiones entre diferentes tipos de datos utilizando funciones específicas o operadores de conversión.

A número:

Se convierte a número utilizando la función as.numeric():

date2 <- as.POSIXct("2023-09-28 15:23")
as.numeric(date2)

[1] 1695932580

m <- FALSE
as.numeric(m)

[1] 0

a <- "123"
as.numeric(a)

[1] 123

A caracter:
1. Se convierte a caracter utilizando la función as.character():
```
b <- TRUE
as.character(b)
```
```
[1] "TRUE"
```
A lógico:

Puedes convertir un número a un valor lógico utilizando la función as.logical().
```
as.logical(5)
```
```
[1] TRUE
```
```
as.logical(0)
```
```
[1] FALSE
```