---

title: "Homework 2"

output: Nestor Gonzalez
---
#####******** PARTE I ********#######

###### FUNCIONES EN R #############

##### PARAMETROS OBLIGATORIOS #######

Los argumentos de una función son una serie de valores (opcionales) que se pasan a
la función, de modo que ciertas variables dentro de estas posean diferentes valores
en cada llamada a la función.
Cuando se hace un llamado a una función, el orden en que se pasan los valores de
los argumentos corresponde con la ubicación de estos en la delación de la función.
Por ejemplo, en el caso anterior, el valor 2 se pasa a la variable lado1, mientras
que el valor 3 se pasa a la variable lado2. Si queremos indicar explícitamente que
valor asignar a cada argumento debemos indicar el nombre de este al llamar a la
función.

```{r}

area_rectangulo <- function(lado1, lado2)

{
area <- lado1 * lado2
print(paste("el área es ", area))
}
area_rectangulo(lado1 = 2, lado2 = 3)

```

##### PARAMETROS CON VALOR PREDETERMINADO #######

Parametro con valor predeterminado en R. Se almacenan como números o enteros.

Podemos verlo en el conjunto de datos a continuación. mtcars es un conjunto de
datos integrado.
Recoge información sobre diferentes tipos de coches.
Podemos importarlo usando mtcars y verificar la clase de la variable mpg, milla por
galón. Devuelve un valor numérico, que indica una variable continua.

```{r}
dataset <- mtcars
dataset
class(dataset$mpg)
```

##### PARAMETROS DE LISTA #######

¿Qué es una lista en R? Una lista es una colección ordenada de cualquier objeto de
R. A diferencia de los vectores y las matrices, donde los elementos deben ser del
mismo tipo, en el caso de las listas los elementos pueden ser de un tipo diferente
o almacenar distintas estructuras.

```{r}

a <- c(45, 12, 56, 14, 16)

b <- c("Vehiculo", "Motocicleta")
c <- matrix(1:12, ncol = 4, byrow = TRUE)

# Creando una lista

mi_lista <- list(a, b, c)
mi_lista
```

##### PARAMETROS DE PASO DE FUNCIÓN #######

Para crear una función se usa la palabra reservada function. A continuación se
enumeran los parámetros formales de la función separados por comas y encerrados
entre paréntesis (en el ejemplo los parámetros formales son a y b). Después viene
el código de la función. Puesto que el código del ejemplo tiene más de una
instrucción, hay que encerrarlo entre llaves. Con esto se crea un objeto función
que se asigna a la variable M.

Una vez creado el objeto función y haber sido asignado a maximo, en el ejemplo
aparecen dos invocaciones a la función. En la primera se usan los parámetros reales
6 y 2, y en la segunda 20 y la expresión y + 7. Al invocar a una función se evalúan
las expresiones que conforman los parámetros reales y se emparejan con los
parámetros formales, es decir, a cada parámetro formal se le asigna el resultado de
evaluar la expresión usada como parámetro real. Los parámetros formales son
variables que reciben la información de entrada de la función (en el ejemplo, a y
b). Una vez emparejados parámetros reales con formales se ejecutan las
instrucciones de la función. Una función devuelve como salida el resultado de
evaluar la última instrucción que ejecuta. En el ejemplo, la última instrucción
ejecutada es m, que es una expresión que produce el máximo de los dos valores de
entrada de la función (almacenados en a y b). Veamos otros ejemplos de invocación a
la función M:

```{r}
M <- function(a,b){
if (a < b){
m<-a

}else{
m <- b
}
m
}

y <- 1
M (8, y + 6)
```

##### FUNCIÓN RETURN #######

La función return tiene un parámetro y produce el siguiente efecto:
termina la ejecución de la función en la que se ejecuta y el valor devuelto por la
función es el parámetro con que es invocada return. Por ejemplo:

```{r}
## buscar valor más mayor usando una funcion

maximo <- function(a, b){

if (a > b){
 m <- a
}else{
m <- b
}
return(m)
}

maximo(5, 10)

```

##### VARIABLES LOCALES Y GLOBALES #######

Variables Locales:
Una función puede realizar cálculos complejos, por lo que a veces necesita usar
variables para almacenar los resultados intermedios de sus cálculos. Por ejemplo,
la siguiente función calcula la suma de los elementos de un vector:
```{r}
# La función suma los elementos del vector (recibido en vec_1)

sumar <- function(vec_1){

temporal <- 0
for ( x in vec_1){
temporal <- temporal + x
}
temporal
}

sumar(c(5, 7, -8))
```
Las variables creadas dentro de la función se llaman VARIABLES LOCALES. ejemplo la
variable "temporal" es una variable local que se usa para acumular los elementos
del vector. las variables locales, junto con los parámetros formales, se crean al
ejecutarse la función y desaparecen al terminar su ejecución. Las variables locales
y parámetros formales son independientes de otras variables que puedan existir
fuera de la función con el mismo nombre.

Variables Globales:
Una variable global de un programa es aquella que se ha creado o definido fuera del
cuerpo de cualquier función.
Una función también puede usar variables globales. Por ejemplo:

```{r}
glob_1 <- 10

sumar_2 <- function(y){

y + glob_1
}

sumar_2(8)

```
La función "sumar_2" usa el valor de la variable "glob_1" que no es una variable
local, sino que es global a la función (ha sido creada fuera).
En general, el uso de variables globales no es considerada una buena práctica de
programación.
##### FUNCIONES QUE DEVUELVEN VARIOS VALORES #######
Algunas funciones tienen que devolver màs de un valor. Sin embargo, las funciones
de R sólo pueden devolver un objeto, resultado de evaluar una expresión.
Por lo tanto, cuando queramos devolver más de un dato habrá que devolver un objeto
que almacene una colección de datos, como un vector, factor, matriz, lista o data
frame.
Habrá que elegir el tipo de objeto que creamos que sea más adecuado a nuestros
cálculos.
Por ejemplo, la función range devuelve el mínimo y el máximo de los elementos de un
vector:

```{r}
# el rango de los valores en un vector
# Los parámetros de entrada: vec, es el vector
datos <- function(vec){
c(min(vec), max(vec))
}

(vec <- sample(20,5)) # se escogen 5 numeros aleatorios entre 1 y 20

datos(vec) # se ingresa el vector a la función y devuelve el minimo y el maximo

range(vec) # range devuelve un vector que contiene el minimo y el máximo de todos

los argumentos dados.

```

#####******** PARTE II ********#######

```{r}

Tarea_especial <- function(A,B,C)

{
{

{
C <- matrix(0, nrow = ncol(A), ncol = nrow(A))
for (i in 1:nrow(A)) {
for (j in 1:ncol(A)) {
C[j, i] <- C[j, i] + A[i, j]
}
}
}

# matriz 4 X 2 Transpuesta

{
D <- matrix(0, nrow = ncol(B), ncol = nrow(B))
for (i in 1:nrow(B)) {
for (j in 1:ncol(B)) {
D[j, i] <- D[j, i] + B[i, j]
}
}
 }

## Multiplicar matriz 1 x matriz 2

{
C <- matrix(0, nrow = nrow(A), ncol = ncol(B))
for (i in 1:nrow(A)) {
for (j in 1:ncol(B)) {
for (k in 1:ncol(A)) {
C[i, j] <- C[i, j] + A[i, k] * B[k, j]
}
}
}
}

## Elevar al cubo la matriz del segundo parámetro y luego multiplique el

resultado con el valor numérico por defecto o sea el valor "5"

{
E <- matrix(0, nrow = nrow(B), ncol = ncol(B))
for (i in 1:nrow(B)) {
for (j in 1:ncol(B)) {
E[i, j] <- E[i, j] + B[i, j]*B[i,j]*B[i,j]
}
}
}

{
H <- matrix(0, nrow = nrow(B), ncol = ncol(B))
for (i in 1:nrow(B)) {
for (j in 1:ncol(B)) {
H[i, j] <- H[i, j] + E[i, j]*5
}
}
}
print("######## matriz 4 X 2 transpuesta -> 2 X 4 #####")
print(C)
print("######## matriz 1 multiplicada por matriz 2 #####")
print(D)
print("######## matriz 2 elevada al cubo #####")
print(E)
print("######## matriz 2 elevada al cubo y multiplicada por valor por defecto 5
#####")
print(H)
}
}
#rm(list =ls()) ### borra la memoria

#Contruir matriz de 3X4 secuencia de 3 y guardarla en una variable

X <- seq(3,36, length=12) # crear valores en secuencia de 3 en 3, 12 valores

M1 <- matrix(X, nrow = 3, ncol = 4, byrow = TRUE) # se ingresan los valores
generados en el vector X y se introducen en la matriz
Y <- seq(4,32, length=8) # crear valores en secuencia de 4 en 4, 8 valores
M2 <- matrix(Y, nrow = 4, ncol = 2, byrow = FALSE) # se ingresan los valores
generados en el vector Y y se introducen en la matriz
Tarea_especial(M1,M2,5)

```