UNIVERSIDAD DEL VALLE DE MÉXICO

PROGRAMACIÓN CONCURRENTE

UNIDAD 3. MODELOS PARA PROGRAMACION CONCURRENTE Y ALGORITMOS PARA EL PROBLEMA DE SECCION

CRITICA

Actividad 9. Proyecto integrador etapa 3

.

Docente: CESAR GARCÍA MARTÍNEZ

Equipo 2:
DIEGO TRISTAN MEZA GARCÍA
CAROLINA MONTES DE OCA GÓMEZ
TANIA PACHUCA SOLARES

16/10/2023
Etapa 1 del Proyecto integrador
I. Identificación y análisis de la programación concurrente
1.1 Identificación de las primitivas de PVM (Parallel Virtual Machine) en C

Cuando estamos trabajando en un programa que se ejecutará en la Máquina Virtual

Paralela, es esencial incorporar las bibliotecas de PVM. Las funciones de PVM
desempeñan un papel fundamental en la gestión de las tres etapas de un algoritmo paralelo.
 Reconocimiento de la Biblioteca PVM como una Máquina Virtual Paralela.

 Identificación de la librería PVM como máquina virtual paralela

LAS FUNCIONES DE PVM: Se dividen en 5 clases:
PVM_ROOT Estas funciones están relacionadas
con la administración de procesos y
recursos en la máquina virtual
paralela. PVM_ROOT se encarga de la
gestión principal y la coordinación de
la ejecución paralela.
PVM_EXPORT Las funciones en esta categoría están
destinadas a la comunicación y el
intercambio de datos entre los
procesos paralelos en la Máquina
Virtual Paralela. Facilitan la
transferencia de información entre
nodos de manera eficiente.
PVM_DEBUGGER Estas funciones son útiles para la
depuración y el monitoreo de
programas paralelos ejecutados en
PVM. Ayudan a los programadores a
identificar y solucionar problemas en
su código.
PVM_DPATH se refiere a las funciones relacionadas
con la administración de la estructura
de directorios en PVM. Esto puede ser
útil para organizar y acceder a
recursos compartidos por procesos
paralelos.
PVM_ARCH Estas funciones están relacionadas
con la detección y configuración de la
arquitectura de hardware de los nodos
en la máquina virtual paralela. Ayudan
a adaptar la ejecución paralela a las
características específicas del
hardware.
PVM_SOCK Estas funciones están relacionadas
con la comunicación entre nodos a
 través de sockets en PVM. Facilitan la
comunicación y la sincronización entre
procesos paralelos mediante el uso de
sockets.
PVM_EPID La categoría PVM_EPID se enfoca en
la gestión de identificadores de
proceso en la máquina virtual paralela.
Proporciona funciones para asignar y
gestionar identificadores únicos para
cada proceso paralelo.
PVM_TMASK Estas funciones están relacionadas
con la administración de máscaras de
temporización en PVM. Permiten a los
programadores controlar la
sincronización temporal de sus
procesos paralelos.

1.2 Determinación de la funcionalidad de PVM en Java

• Realizar un programa que verifique la comunicación entre el cliente y
el servidor, por ejemplo, el más simple HolaMundo.c, para verificar la
funcionalidad entre los nodos.

II. Identificar las funcionalidades de la programación concurrente

2.1 Elaborar un programa en C que sume los números dado un rango
de números
Primero ingresamos las libraries
#include<iostream>
#include<conio.h>
Se van a necesitar 3 variables n,n2, y suma (los nombres de las variables
son cualquiera.
La variable suma se define como suma=0, para que no almacene ningún
valor
Después con la instrucción establecemos que en pantalla salga el mensaje
que esta entre comillas, se pone 2 tabulaciones con la diagonal t
La diagonal n salta baja una línea
cout<<"\t\tDigite el número de elementos a procesar:\n";
cout<<"\t\t";
con esta instrucción solicito que introduzcan por teclado el valor cin>>n;
la instrucción for va a contar de 1 hasta el que se cumpla la condición de el
valor que acabamos de introducir por ello se necesita declarar una variable
nueva en este
aso i
 for (int i=1;
este fragmento va a realizar el incremento de la variable es decir al inicio la
variable vale 1 más 1 en la siguiente vuelta vale 2 y así hasta llegar al tope
que se introdujo al principio i<=n;i++) {
En pantalla imprimimos el mensaje cout<<"\t\tDigite el numero:"; aceptamos
el valor que se va a ir sumando cin>>n2; realizamos la operación de la
suma
suma=suma+n2;
mostramos el resultado de la operación de suma cout<<"\n\t\t la suma
es:"<<suma<<endl;
system ("PAUSE");
return 0;
El programa puede sumar desde que quieras ingresar 1 valor hasta 100
valores o más y determina el resultado
#include<iostream>
#include<conio.h>

using namespace std;

//INCIO DE FUNCIONES

//FUNCION PARA PEDIR DATOS

void pedir_datos();
void pedir_datos2();
void Mostrar();

//Variables globales

int n,n2[4],suma=0;

//FUNCION MAIN
int main(){

pedir_datos();
pedir_datos2();
Mostrar();

getch();
return 0;
}

//Desarrollo de funcion

//Pedir datos

void pedir_datos(){

cout<<"Digite el numero de elementos a procesar: ";

 cin>>n;

//Pedir numeros para el vector

void pedir_datos2(){

system("cls");

for (int i=0; i<n;i++) {

cout<<"Digite el numero :";
cin>>n2[i];
suma=suma+n2[i];
}

//mostrar

void Mostrar(){

cout<<"\nla suma del vector es :"<<suma<<endl;

}
1. Primero. Realiza el programa usando un enfoque secuencial (sin
paralelismo) observando su comportamiento
 Para este punto se utilizaron 2 máquinas virtuales llamadas Mater y otro
Slave1 con las imágenes de Linux MINT (para no tener problemas a un
futuro con pvm3 se modifican los nombres del usuario de las
maquinas).

 Una vez instalados en virtual box ejecutamos los programas, abrimos la

terminal para instalar openssh server en ambos maquinas
  configura la dirección IP en ambos ordenadores para la comunicación entre
las dos máquinas virtuales

Después utilizando las terminales de cada uno se tiene que verificar la comunicación entre ellos
 Se agregan las direcciones modificadas al host en ambas maquinas

 Después, en el en Mater se configura el paquete de openssh

 Una vez muy bien configurada el paquete, instalaremos PVM3 en amabas maquinas

 Una vez extraído, se copia la carpeta pvm3 y se pega en el escritorio, dentro de la carpeta
abrimos otra llamada bin y creamos una carpeta llamada LINUX64 (ahí se ejecutaran
nuestros códigos de hello y hello_other que se encuentran en la carpeta examples en
pvm3) en ambas máquinas.
 Después, instalaremos pvm3 en ambas máquinas.

 Una vez finalizado la instalación, agregaremos las variables de entorno en bash

 Este procedimiento lo hacemos en ambas máquinas.
 “Escucharemos ” los códigos en la maquina Master
 Procederemos a compilar en la terminal del SO
 DEBEMOS COPIAR LOS ARCHIVO hello y hello_other A SLAVE1

 Abrimos otra terminal y ejecutamos pvm

 Y compilaremos el código hello

En esta ultima imagen podemos observar que la respuesta es desde el Master

Y nos imprime desde la computadora Slave1

Etapa 2 del Proyecto integrador
Introducción

En la segunda etapa de nuestro proyecto integrador, nos sumergiremos en los

fundamentales conceptos de sección crítica y exclusión mutua. Estos conceptos
son esenciales para comprender la gran mayoría de los desafíos que surgen en el
ámbito de la programación concurrente. Además, exploraremos la aplicación de
herramientas clave como monitores y semáforos en el contexto de Java, con el
objetivo de abordar y resolver eficazmente estos desafíos. A través de esta
exploración, obtendremos una comprensión más profunda de cómo funcionan
estos elementos en la programación concurrente.

III. identificar los conceptos y problemas en programación secuencial de sección

crítica y exclusión mutua

3.1 Identificar la exclusión mutua y la sección crítica

 Identificación de una sección crítica como la memoria, un espacio de memoria,

disco duro, entre otros ejemplos.

En el ámbito de los sistemas operativos, es común que los procesos que

trabajan en conjunto necesiten compartir un espacio de almacenamiento
común en el cual puedan realizar operaciones de lectura y escritura. Este
espacio compartido puede residir en la memoria principal del sistema o
manifestarse como un archivo compartido en el sistema de archivos. Es
importante destacar que la ubicación específica de la memoria compartida
no altera la naturaleza fundamental de la comunicación o de los desafíos
que pueden surgir al trabajar con ella.
Memoria Compartida en la Memoria Principal:
Cuando se trata de memoria compartida en la memoria principal, varios procesos
pueden acceder a una región de la memoria que se reserva para este propósito.
En este contexto, la memoria compartida actúa como un medio eficiente para que
los procesos intercambien información en tiempo real. Esto es particularmente útil
en situaciones donde la sincronización y la comunicación entre procesos son
esenciales. Sin embargo, la gestión adecuada de esta memoria compartida es
crítica para evitar conflictos y garantizar la integridad de los datos.
Archivos Compartidos:
En contraste, los archivos compartidos se utilizan para la comunicación entre
procesos cuando es necesario compartir información de manera persistente. Estos
archivos pueden residir en el sistema de archivos y ser accedidos por varios
procesos de manera simultánea. La sincronización y la exclusión mutua siguen
siendo preocupaciones importantes incluso cuando se utilizan archivos
compartidos, ya que varios procesos pueden intentar leer o escribir en el archivo al
mismo tiempo.
Naturaleza de los Problemas en la Comunicación y Sincronización:
Independientemente de si la memoria compartida se encuentra en la memoria
principal o como un archivo compartido, la comunicación y la sincronización entre
procesos plantean desafíos inherentes. Estos desafíos incluyen la necesidad de
establecer mecanismos de exclusión mutua para garantizar que un proceso no
modifique los datos compartidos mientras otro proceso está realizando una
operación crítica. También es crucial manejar la concurrencia y prevenir
condiciones de carrera, en las cuales múltiples procesos intentan acceder o
modificar los datos compartidos al mismo tiempo, lo que puede conducir a
resultados impredecibles y errores en la aplicación.
En resumen, la utilización de memoria compartida, ya sea en la memoria principal
o como archivos compartidos, es una estrategia fundamental en la programación
concurrente. Comprender los conceptos de exclusión mutua, sincronización y la
gestión de datos compartidos es esencial para desarrollar aplicaciones robustas y
eficientes en entornos donde varios procesos deben colaborar y compartir
recursos.
Ejemplo: Coordinación en un Sistema de Reservas de Asientos de Avión
Imagina un sistema de reservas de asientos de avión en el que múltiples procesos o hilos
intentan reservar asientos para vuelos. En este sistema, hay un conjunto de asientos
disponibles, y cada proceso intenta seleccionar y reservar un asiento vacío.
La Sección Crítica:
La sección crítica en este caso es el proceso de seleccionar y reservar un asiento. Solo un
proceso debe poder realizar esta operación a la vez para evitar situaciones de sobreventa o
la asignación duplicada del mismo asiento a múltiples pasajeros.
Proceso de Reserva Concurrente:
Supongamos que dos procesos, Pasajero A y Pasajero B, intentan reservar un asiento al
mismo tiempo. Ambos procesos acceden a la lista de asientos disponibles y observan que el
asiento número 3 está disponible.
1. Pasajero A: Lee que el asiento 3 está disponible y procede a reservarlo.
2. Pasajero B: Al mismo tiempo, también lee que el asiento 3 está disponible y decide
reservarlo.
En este punto, ambos pasajeros han determinado que el asiento 3 está libre y están a punto
de realizar la reserva. Sin embargo, si no se implementa una sección crítica adecuada,
podríamos tener un problema.
Problema sin la Sección Crítica:
Supongamos que no se utiliza una sección crítica y ambos pasajeros intentan reservar el
asiento al mismo tiempo sin ningún control de acceso compartido.
Esto podría llevar a que ambos pasajeros reserven el mismo asiento, lo que causaría
conflictos y problemas en el sistema.
Solución con Sección Crítica:
Con una sección crítica adecuada, solo un pasajero puede ingresar y reservar un asiento a la
vez. Esto garantiza que ningún otro pasajero pueda reservar el mismo asiento
simultáneamente. La sección crítica se implementa mediante mecanismos como semáforos,
mutex o bloqueo de hilos para coordinar el acceso concurrente a los recursos compartidos,
en este caso, los asientos disponibles.
En resumen, la sección crítica es fundamental para garantizar la integridad de los datos y
evitar conflictos en situaciones de programación concurrente, como en un sistema de
reservas de asientos de avión. Permite que los procesos accedan a los recursos compartidos
de manera controlada y segura, evitando problemas como la sobreventa de asientos en este
ejemplo.

 Identificación de la exclusión mutua al respecto de los procesos, para comprender

el funcionamiento de los sistemas en general.

La exclusión mutua es un concepto fundamental en la programación concurrente

que asegura que cuando un proceso utiliza un recurso compartido, otros procesos
no pueden acceder a ese recurso al mismo tiempo durante la ejecución del
programa. Para lograr una solución efectiva de exclusión mutua, es esencial
cumplir con cuatro condiciones clave:
1. No Superposición en Secciones Críticas: La primera condición implica
que dos procesos no pueden ejecutar sus secciones críticas
simultáneamente. Esto garantiza que los procesos no entren en conflicto y
no accedan al recurso compartido al mismo tiempo, lo que podría llevar a
resultados inesperados o errores en el programa.
2. Independencia de la Velocidad y Número de CPU: La segunda condición
se refiere a que no se deben hacer suposiciones sobre la velocidad de
ejecución de los procesos ni sobre la cantidad de unidades de
procesamiento (CPU) disponibles. La solución de exclusión mutua debe
funcionar de manera confiable independientemente de la velocidad de los
procesos o de la infraestructura subyacente.
3. No Bloqueo Mutuo: La tercera condición implica que ningún proceso en
ejecución fuera de su sección crítica debe bloquear innecesariamente a
otros procesos. En otras palabras, un proceso no debe retener un recurso
compartido de manera indefinida, lo que podría resultar en un cuello de
botella o una falta de progreso en otros procesos.
4. Ausencia de Espera Infinita: La cuarta y última condición establece que
ningún proceso debe quedarse esperando indefinidamente para ingresar a
su sección crítica. Garantizar que todos los procesos tengan la oportunidad
de acceder a la sección crítica de manera justa y oportuna es esencial para
evitar bloqueos permanentes y garantizar la continuidad de la ejecución del
programa.

3.2 Identificar los problemas que presentan la exclusión mutua y la sección crítica en
programación secuencial

 Identificar como la exclusión mutua involucra la determinación de las prioridades

para el uso de una sección crítica al corrimiento del tiempo.

3.2 Identificar los Problemas de la Exclusión Mutua y la Sección Crítica en

Programación Secuencial
En esta sección, exploraremos los desafíos y problemas que pueden surgir al
implementar la exclusión mutua y gestionar secciones críticas en programación
secuencial. Identificar estos problemas es fundamental para comprender la
importancia de una implementación adecuada.
3.2.1 Prioridades en el Uso de Secciones Críticas
Uno de los problemas clave relacionados con la exclusión mutua es la
determinación de las prioridades para el acceso a una sección crítica. Cuando
varios procesos compiten por acceder a la sección crítica, puede surgir la pregunta
de cuál proceso debería tener prioridad. Esto se vuelve especialmente relevante
cuando se utilizan recursos compartidos críticos, y diferentes procesos pueden
tener requisitos específicos.
Por ejemplo, en un sistema de control de tráfico aéreo, puede ser crucial que los
procesos que manejan aterrizajes tengan prioridad sobre los que gestionan
despegues, ya que la seguridad de las aeronaves en aproximación es primordial.
La determinación de estas prioridades puede ser compleja y debe ser
cuidadosamente diseñada para garantizar un funcionamiento eficiente y seguro
del sistema.
3.2.2 El Corrimiento del Tiempo
Otro desafío es el "corrimiento del tiempo" en el contexto de la exclusión mutua.
Esto se refiere a situaciones en las que un proceso puede bloquearse
indefinidamente mientras espera el acceso a una sección crítica. Esto puede
ocurrir cuando un proceso que ya está dentro de la sección crítica se ejecuta
durante un período prolongado, lo que impide que otros procesos ingresen.
Imaginemos un sistema de gestión de recursos compartidos donde un proceso A
ingresa a una sección crítica y realiza una operación que puede llevar mucho
tiempo, como la escritura de datos en un archivo. Si no se controla
adecuadamente, otros procesos que intentan acceder a la misma sección crítica
pueden quedar bloqueados indefinidamente, lo que resulta en un rendimiento
deficiente y, en algunos casos, un bloqueo total del sistema.
La gestión del corrimiento del tiempo implica implementar mecanismos que eviten
que un proceso monopolice una sección crítica y garantice que otros procesos
tengan la oportunidad de acceder de manera justa y oportuna.
En resumen, la identificación de problemas como la determinación de prioridades
y el corrimiento del tiempo en el contexto de la exclusión mutua y las secciones
críticas es esencial para diseñar soluciones robustas en programación secuencial.
Abordar estos problemas adecuadamente es crucial para garantizar un
comportamiento predecible y eficiente de los sistemas concurrentes.

IV. Aplicar la programación concurrente para solucionar problemas clásicos de

sección crítica y exclusión mutua
4.1 Aplicar la programación concurrente en los problemas: los filósofos comelones y
lectores/escritores

 Exponer de manera general el problema de los filósofos comelones y

lectores/escritores utilizando Java

Problema 1 Filósofos comelones:

Consideramos 5 filósofos que comparten una mesa redonda con cinco sillas, una
para cada filósofo. En el centro de la mesa hay una fuente de arroz y la mesa se
ha puesto con sólo cinco palillos Cuando un filósofo piensa, no se relaciona, pero
cuando un filósofo siente hambre toma los palillos más próximos a él los cuales
van de izquierda y a la derecha. Un filósofo sólo puede tomar un palillo cada vez,
pero no puede tomar un palillo que esté en manos de otro filosofo Cuando un
filósofo hambriento ha conseguido dos palillos, come sin soltar sus palillos, cuando
termina de comer, los coloca de nuevo sobre la mesa y vuelve a pensar.
Resultado de la ejecución:
 Problema Lectores / escritores

En este problema presentare el siguiente código en dev c++ utilizado semáforos

en programación concurrente. El Problema Lectores / escritores contiene una
incógnita compartida en donde varios procesos puedan acceder parta escribir
datos o leer datos.

En el código se pone <mutex> y < condition_variable> para haya una

sincronización entre los hilos.

Después de hace una declaración de constantes ya que definen el número de

escritores, lectores e iteraciones.

- Mtx: se utiliza para controlar el de las variables compartidas.

 - read_cv y write_cv: sincroniza hilos.
- readers_waiting, active_readers y active_writers: rastrea el estado de
los hilos.
- shared_data: variable compartida donde los escritores escribirán y los
lectores leerán.

Función ReaderFunction: representa el comportamiento de los hilos lectores.

Cada lector intenta leer la variable shared_data en un bucle.
El lector obtiene un bloqueo mutex y verifica si hay escritores activos. Si hay
escritores, se mantiene un momento en la variable de condición read_cv.
Incrementa readers_waiting para rastrear el número de lectores en reposo.
Desbloquea el mutex y lee el valor de shared_data.
Disminuye readers_waiting y, en caso de que no haya más lectores esperando,
notificará a los escritores con write_cv.
En la función WriterFunction se representa el comportamiento de los hilos escritores.

Cada escritor intenta escribir en la variable shared_data en for.

El escritor adquiere un bloqueo mutex y verifica si hay lectores o escritores

disponibles.En caso de que los haya, espera en la variable de condición write_cv.

Se incrementa active_writers para rastrear el número de escritores activos.

Se incrementa el valor de shared_data.

Se disminuye active_writers y notifica a otros escritores y a los lectores.

Resultados
CONCLUSIÓN

En este proyecto, hemos explorado en profundidad los conceptos fundamentales

de la exclusión mutua y las secciones críticas en el contexto de la programación
concurrente. Estos conceptos son esenciales para garantizar la integridad de los
datos y la coordinación efectiva entre procesos o hilos en sistemas concurrentes.
A lo largo de nuestro estudio, hemos identificado los desafíos y problemas
asociados con la exclusión mutua y las secciones críticas, lo que nos ha permitido
comprender mejor la importancia de una implementación adecuada y cuidadosa.
Hemos aprendido que la exclusión mutua es fundamental para evitar conflictos y
garantizar que solo un proceso a la vez pueda acceder a recursos compartidos
críticos. Sin embargo, la determinación de prioridades y la gestión del corrimiento
del tiempo son aspectos clave que deben abordarse para lograr una
implementación efectiva de la exclusión mutua.
Además, hemos reconocido que la programación concurrente presenta desafíos
únicos y complejos que van más allá de la simple gestión de recursos
compartidos. La coordinación y sincronización entre procesos son cruciales para
evitar condiciones de carrera, bloqueos y problemas de rendimiento.
En última instancia, nuestro proyecto nos ha brindado una comprensión más
profunda de cómo diseñar soluciones seguras y eficientes en sistemas
concurrentes. La programación concurrente desempeña un papel esencial en una
amplia gama de aplicaciones, desde sistemas operativos hasta aplicaciones web y
dispositivos embebidos. La capacidad de comprender y aplicar los conceptos de
exclusión mutua y sección crítica es una habilidad valiosa para cualquier
desarrollador o ingeniero de software que trabaje en entornos donde la
concurrencia es un factor crítico.
Etapa 3 del Proyecto integrador

V. Describir de manera general el algoritmo de Jacobi para solución de

sistemas de ecuaciones lineales.
5.1 Identificar los métodos de solución para sistemas de ecuaciones lineales
• Investigar acerca de los sistemas de ecuaciones lineales, su definición y como se
pueden solucionar
Un sistema de ecuaciones lineales es un conjunto de dos o más ecuaciones de
primer grado, en el cual se relacionan dos o más incógnitas.
En los sistemas de ecuaciones, se debe buscar los valores de las incógnitas con
los cuales al reemplazar deben dar la solución planteada en ambas ecuaciones.
El modelo matemático de un sistema de ecuaciones lineales se representa así:
𝑎11𝑥1 + 𝑎12𝑥2 + 𝑎13𝑥3 = 𝑏1
𝑎21𝑥1 + 𝑎22𝑥2 + 𝑎23𝑥3 = 𝑏2
𝑎31𝑥1 + 𝑎32𝑥2 + 𝑎33𝑥3 = 𝑏3
Este sistema está conformado por tres ecuaciones con tres incógnitas 𝑥𝑖 y
variables expresadas a la primera potencia
Existen diversos métodos para resolver un sistema de ecuaciones lineales. Su
elección depende de la propia complejidad del sistema o el número de ecuaciones
al igual que del número de incógnitas, de los componentes que conforman al
sistema y en general de los atributos del sistema en consideración.
La solución de sistemas de ecuaciones lineales usando el método de Jacobi

Dado un sistema S ≡ Ax = b, el método de Jacobi consiste en iterar el sistema de

punto fijo
x=( D−A ) X +b , es decir,
( k −1 )
DX ( K )=( D− A ) x + b donde D es la matriz diagonal (regular) cuyos elementos
son los de la diagonal de A, equivale a despejar las incógnitas de los elementos de
la diagonal en S
Imagen recuperada de:
El método de Jacobi se aplica siguiendo la siguiente secuencia de pasos:
1. Se sustituye en el segundo miembro las incógnitas por la estimación inicial.

0 0 0 0
x 1=x 1 , x 2=x 2 , x 3 =x3 , x 4 … . , x n=x n

Los valores obtenidos en el primer miembro constituyen la primera aproximación

(1 )
x

x (1 )=( x 11 , x 12 , x 13 … x1n )

2. se sustituye en el segundo miembro las incógnitas por la aproximación

obtenida en el paso anterior.
1 1 1 1
x 1=x 1 , x 2=x 2 , x 3=x 3 , x 4 … . , x n=x n
Los valores obtenidos en el primer miembro constituyen la segunda
aproximación x (2 )

x (2 )=( x 21 , x 22 , x 23 … x2n)

En general:

Imagen recuperada de:

Se utiliza como criterio una cota de la diferencia en norma entre dos
aproximaciones (iterados) consecutivas

• Identificación de los métodos de solución directos e iterativos para

sistemas de ecuaciones lineales

En general, los métodos que resuelven modelos de sistemas lineales se clasifican

en 3 tipos: directos e indirectos y métodos Iterativos.
 En un método directo se obtiene un número fijo de pasos que no están
sujetos a errores por iteraciones, aunque sí por cálculos aritméticos entre
los más importantes se
encuentran: eliminación gaussiana, máximo elemento pivote,
descomposición LU, por
inversa de la matriz, Gauss- Jordan y descomposición de Cholesky

 Los métodos indirectos también llamados métodos iterativos son muy útiles
en sistemas
lineales mayores de orden 15 (o sea, n=15 renglones i*15 columnas j).
Están estructurados en la forma simbólica
y 1= y 0 + Δ y 0
y 2= y 1 + Δ y 1

y n= y n−1+ Δ y n−1
El valor actual es igual, al valor anterior más un incremento que depende
del
procedimiento en cuestión.
En estos métodos se realizan iteraciones para aproximarse a la solución de
𝑥 = [𝑥𝑖] aprovechando las características de la matriz de coeficientes A, y
tratando de usar un
 menor número de pasos que en un método directo. Algunos de los métodos
más
conocidos son Jacobi, Gauss-Seidel y sobre relajaciones sucesivas (SOR).

Los métodos indirectos aceleran la convergencia hacia una solución,

aunque se asocian
al concepto de error por las operaciones que conllevan cocientes entre
elementos a ij
de la matriz y a iide la diagonal principal, esto especialmente, cuando a iies
relativamente pequeño con respecto a ij.

 Un método iterativo para resolver un sistema de ecuaciones lineales Ax = b

comienza con una aproximación inicial x(0), a partir de la cual se construye
una sucesión {x(k)}∞k=0 de vectores que se espera converja a la solución
exacta x = A−1b, es decir:

Consideramos los métodos iterativos estacionarios donde la sucesión {x(k)}

se construye de la forma

Si denotamos por c ( k )=x ( k )−x el error en el paso k-esimo de la iteración, la

1

condición
de convergencia equivale a exigir que

5.2 Describir el método de Jacobi mediante el algoritmo que resuelve un

sistema de ecuaciones lineales general.
 Exponer el algoritmo de Jacobi y describir su desarrollo
 Resolver un sistema de ecuaciones de tamaño 3x3 mediante el método
de Jacobi
 Explicar las soluciones de Jacobi de manera manual
El algoritmo de jacobi es muy utilizado para resolver sistemas de ecuaciones
lineales. Su función mediante la iteración de un sistema para obtener una
aproximación a la solución:
Algoritmo:
1. En un sistema de ecuaciones lineales Ax = b.
Donde:
A = matriz de coeficientes.
X = vector de incógnitas.
B = vector de términos constantes, inicializa un vector de solución x0. Este
puede ser un vector de ceros o cualquier otro valor inicial.

2. Se hace una Iteración en el siguiente proceso hasta que se cumpla un

criterio de convergencia:

Para cada variable xi en el vector de solución x en la iteración actual,

calcula su nuevo valor utilizando la fórmula de Jacobi:

(k +1)
xi = (bi - Σ(Aij * xj (k )) para j ≠ i) / Aii

Donde:

i = representa la fila i..ésima de la matriz A.

j = índice de la variable en la fila i..ésima.
k = número de la iteración actual.

3. Se hace una verificación en un criterio de convergencia, que puede ser una

cierta cantidad de iteraciones máximas, un error absoluto o cualquier otro
criterio definido.

4. En caso de que no se cumpla el criterio de convergencia, se retorna o

regresa al paso número 2 y continúa iterando.
 5. El vector x contiene una aproximación a la solución del sistema de
ecuaciones cuando se cumpla el criterio de convergencia.

Solución de un sistema 3x3 con el método de Jacobi:

1x + 2y - z = 6
2x + 8y + z = 7
3x - 2y + 4z = 9

Se puede representar en forma matricial como Ax = b, donde:

A = | 1 2 -1 |
|2 8 1 |
| 3 -2 4 |

x=|x|
|y|
|z|

b=|6|
|7|
|9|

Se inicia un vector de solución, ejemplo, x0 = [0, 0, 0], y aplicamos el

algoritmo de Jacobi iterativamente hasta que se cumpla el criterio de
convergencia.

Explicación de las soluciones de Jacobi de forma manual:

Estas soluciones de Jacobi se necesitarían realizar las iteraciones manualmente,

lo que puede ser un proceso algo largo. En cada iteración, se actualizan los
valores de x, y, y z utilizando las fórmulas de Jacobi. Se aproximan a la solución
real con cada iteración.
Referencias

 Jorba, E. y Suppi, R. (2004). Administración Avanzada GNU Linux

Haga clic para ver más opciones [Archivo PDF]. Recuperado de
https://libros.metabiblioteca.org/bitstream/001/425/1/871.pdf
 Fervari, R. (2020). Autómatas Finitos Deterministicos (DFA) Haga
clic para ver más opciones [Archivo PDF]. Recuperado de
https://cs.famaf.unc.edu.ar/~rfervari/icc16/slides/class-1-slides.pdf
 Academia Usero Estepona Videos Educativos (Productor). (06 de
Marzo de 2015). Lectores y escritores con locks Concurrencia
Java [Archivo de video]. Recuperado de
https://www.youtube.com/watch?v=Pq7w9gxcuWA
 Drake, J. y Barros L. (s.f.). Programación Concurrente Haga clic para
ver más opciones [Archivo PDF]. Recuperado de
https://www.ctr.unican.es/asignaturas/procodis_3_II/Doc/Procodis_3_
02.pdf
