<jupyter_start><jupyter_text>Experimento numérico \6 - Tema: Solución de bloques cambiando el tamaño del bloque**Responsable:** <NAME>  0. ObjetivoEste documento pretende mostar los resultados obtenidos con la implementación realizada, en el contexto del se hacen variaciones en el tamaño de los bloques para matrices con número de condición entre $1$ y $10$ del órden de $10^3$.**Nota:** El reporte general de resultados obtenidos con las implementaciones realizadas en este proyecto se puede consultar en el siguiente [vínculo](https://github.com/mno-2020-gh-classroom/ex-modulo-3-comp-matricial-svd-czammar/blob/master/results/Reporte_resultados.ipynb) 1. ConsideracionesAl respecto de los experimentos numéricos realizados para consolidar el presente reporte, tales se basan en las siguientes premisas:[Pendiente: desarrollo]En este sentido, en particular para cada experimento realizado, se reportan según resulte aplicable:* los parámetros empleados en la simulaciones, * las dimensiones de las matrices y vectores involucrados, así como el prodecimiento pseudo-aleatorio que les dio origen, * 1) el tiempo involucrado en correr los experimentos, * 2) número de condición de las matrices pseudo-aleatorias, y * 3) el error relativo obtenido, para la solución de un sistema lineal de la forma $Ax=b$, es decir el cociente$$|| Ax - b ||_2 / || b ||_2$$* 4) La norma de $A$ y de la matriz obtenida al rearmar A tras multiplica las matrices resultantes de la aproximación de la descomposición SVD vía el algoritmo **One-Sided Jacobi** 1.1 Consideraciones sobre la infraestructura empleada**Especificaciones de ambiente común de trabajo**Para realizar el presente experimento numérico se ha empleado la imagen de docker basada en R del curso MNO 2020 (palmoreck/jupyterlab_r_kernel:1.1.0)```docker run --rm -v `pwd`:/datos --name jupyterlab_r_kernel_local -p 8888:8888 -d palmoreck/jupyterlab_r_kernel:1.1.0```*Nota:* el comando "-v \`pwd\`:/datos", permite montar el directorio actual en donde el usuario se encuentre situada en terminal como un volumen de la imagen de docker, dentro del directorio "/datos". 2. Experimento numérico**Objetivo**Modificar el número de condición de la matriz y las dimensiones de los bloques para notar el efecto que tiene sobre el error relativo y el tiempo de ejecución.A tal respecto, se destaca que se realizó este experimentos buscando probar como afecta el tiempo de ejecución el número de bloques seleccionados.**Cargamos codigo desarrollado previamente*** **utils.R:** contiene las funciones auxiliares desarrolladas para el proyecto* **00-load.R:** la implementación del método de eliminación por bloques, empleando la aproximación de la descomposición SVD vía el algoritmo **One-Sided Jacobi**.<jupyter_code>## Instalamos paquetes
rm(list = ls())

paquetes <- c('matrixcalc','pracma')

instalar <- function(paquete) {
  if (!require(paquete,character.only = TRUE, quietly = TRUE, warn.conflicts = FALSE)) {
    install.packages(as.character(paquete), dependecies = TRUE, repos = "http://cran.us.r-project.org")
    library(paquete, character.only = TRUE, quietly = TRUE, warn.conflicts = FALSE)
  }
}


lapply(paquetes, instalar)
## Cargamos paquetes necesarios
library("matrixcalc")
library("pracma")
#source("metadata.R")
source("utils.R")
source("00-load.R")<jupyter_output><empty_output><jupyter_text>2.1 Experimento 6.1Se cambia el número de bloques para diferentes corridas.|  |         Parámetros         | Valor/Rango de valores | Comentarios ||:-:|:--------------------------:|:----------------------:|:-----------:|| 1 |     Dimensiones de $A$     |     $10^2x10^2$                   |             || 2 |        Dimensión $b$       |     $10^2$                   |             || 3 |         Tolerancia         |     $10^{-8}$                   |             || 4 |          Maxsweep          |           5             |             || 5 |   Metodo pseudo-aleatorio  |          SVD jacobi              |            || 6 | Numero de condición de $A$ |          429.54              |     Obtenido con función cond        |**Codigo:** breve descrición de que hace el código y resultados.<jupyter_code>set.seed(231)
n= 10**2
TOL = 10**-8

A = matrix(sample(-100:100,n*n,replace=TRUE), ncol=n)
b = matrix(rnorm(n), ncol=1)


inicio<-Sys.time()
z<-eliminacion_bloques(A,b,n/2,10^-8,5)
print("#####################")
print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "#####################"
[1] "Error relativo"<jupyter_text>**Resultados**Los resultados obtenidos se resumen a través de la siguiente tabla [Pendiente: por favor ajustar tabla según experimento]|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |1.70 mins                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |1.47576                        |                                   || 3 | Tamaño de bloque                         |$50$                        |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,20,10^-8,5)
print("#####################")
print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "#####################"
[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |28.57 seg               |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |2.3343                  |                                   || 3 | Tamaño de bloque                         |$20$                    |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,10,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "#####################"
[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |12.77 seg                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |2.12                        |                                   || 6 | Tamaño de bloque                         |$10$                        |                                   |  2.2  Experimento 6.2Este experimento se basa en los siguientes parámetros [Pendiente: por favor ajustar tabla según experimento]|  |         Parámetros         | Valor/Rango de valores | Comentarios ||:-:|:--------------------------:|:----------------------:|:-----------:|| 1 |     Dimensiones de $A$     |         $10x10$               |             || 2 |        Dimensión $b$       |      10                  |             || 3 |         Tolerancia         |     $10^{-8}$                   |             || 4 |          Maxsweep          |  5                      |             || 5 |   Metodo pseudo-aleatorio  |              |       | 6 | Numero de condición de $A$ |   80.6159                       |      Obtenido con método cond()        |**Codigo:** breve descrición de que hace el código y resultados.<jupyter_code>set.seed(231)
n= 10**1
TOL = 10**-8
lim<-1

A = matrix(runif(n*n,min=-lim,max=lim), ncol=n)
b = matrix(runif(n,min=-lim,max=lim), ncol=1)

cond(A)
inicio<-Sys.time()
z<-eliminacion_bloques(A,b,2,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"<jupyter_text>**Resultados**Los resultados obtenidos se resumen a través de la siguiente tabla [Pendiente: por favor ajustar tabla según experimento]  |  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |0.05477 seg                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |0.7489                        |                                   || 6 | Tamaño de bloque                         |$2$                        |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,5,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |.109 seg                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |1.0271                        |                                   || 6 | Tamaño de bloque                         |$5$                        |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,7,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |0.1003 seg                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |0.8922                        |                                   || 6 | Tamaño de bloque                         |$7$                        |                                   |  2.3  Experimento 6.3Este experimento se basa en los siguientes parámetros |  |         Parámetros         | Valor/Rango de valores | Comentarios ||:-:|:--------------------------:|:----------------------:|:-----------:|| 1 |     Dimensiones de $A$     |    $10^3x10^3$                    |             || 2 |        Dimensión $b$       |    $10^3$                    |             || 3 |         Tolerancia         |    $10^{-8}$                    |             || 4 |          Maxsweep          |    5                    |             || 5 |   Metodo pseudo-aleatorio  |                        |        Obtenido con método XXX    || 6 | Numero de condición de $A$ |    470296                    |     Obtenido con función cond()       |**Codigo:** breve descrición de que hace el código y resultados.<jupyter_code>set.seed(231)
n= 10**2
TOL = 10**-8
lim<-10

A = matrix(rnorm(n*n,mean=50,sd=12), ncol=n)
b = matrix(runif(n,min=-lim,max=lim), ncol=1)

cond(A)
inicio<-Sys.time()
z<-eliminacion_bloques(A,b,50,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |1.085 min                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |1.4911|                                   || 6 | Tamaño de bloque                         |50                      |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,20,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"<jupyter_text>|  |                Parámetros                | Valor/Rango de valores |            Comentarios            ||:-:|:----------------------------------------:|:----------------------:|:---------------------------------:|| 1 |            Tiempo de ejecución           |18.30 seg                        |                                   || 2 |      Error relativo $||Ax-b||/||b||$     |1.2141                        |                                   || 6 | Tamaño de bloque                         |20                      |                                   |<jupyter_code>inicio<-Sys.time()
z<-eliminacion_bloques(A,b,10,10^-8,5)

print("Error relativo")
norm(A%*%z-b,"2")/norm(b,"2")
print("#####################")
print("Número de condición")
cond(A)
print("#####################")
fin<-Sys.time()
fin-inicio<jupyter_output>[1] "Error relativo"
StarcoderdataJupyterStructuredCleanDedup