MANUAL DE PROCEDIMIENTO

CARRERA: INGENIERIA ELECTRONICA PRCTICA: REDES DE COMPUTADORAS II

CTEDRA O MATERIA
EQUIPO: LABORATORIO CISCO RELACIONADA

Responsable /Equipo: REDES DE COMPUTADORAS II REVISIN N: 1

Accesorios:
EDICIN: 1
Computadora

Software Matlab

NMERO DE ESTUDIANTES
POR EQUIPO O PRCTICA:
Fecha:
DOCENTE: 3 estudiantes por puesto
03 de enero de 2017
Ing. Juan Diego Jara Danny Guachichulca
Paola Maribel Guamn
Pedro Jos Pineda

Tema: ALGORITMO VECTOR DISTANCIA.

1. INTRODUCCIN

En este documento se presenta la implementacin realizada del algoritmo Vector Distancia o conocido
tambin como Bellman-Ford, mediante el cual se puede obtener la trayectoria ms corta de un nodo
hacia otro, en este caso se desea obtener las rutas ms cortas para una red en la cual los nodos
estaran representando los diferentes routers, por lo que este algoritmo es utilizado en diferentes
tipos de enrutamiento.
Se especifica las herramientas necesarias para la implementacin del algoritmo, es decir las variables
que deben ser ingresadas, se tiene el diagrama de flujo y el pseudocdigo del algoritmo que detecta
las distancias ms cortas.
Se describe el programa realizado en Matlab, el cual consta de dos formas de implementacin, en la
primera se presenta las distancias desde cada uno de los nodos como inicial a los dems nodos, en
la segunda se especifica un par de nodos y se presenta el camino recorrido el cual ser el que posea
menor distancia.

2. OBJETIVOS

2.1 Objetivo General:

Entender, implementar y verificar el funcionamiento del algoritmo de Vector Distancia o Bellmand-

Ford, en Matlab.

2.2 Objetivos Especficos:

Realizar el pseudocdigo del algoritmo y describirlo

Realizar un diagrama de flujo que especifique el funcionamiento
Implementar el algoritmo en Matlab
Describir el funcionamiento completo del programa realizado en Matlab
 Especificar el tipo de datos que recibe el programa para el funcionamiento del mismo
Mostrar los resultados de la implementacin
Identificar que significa cada resultado obtenido.

3. FUNDAMENTOS TERICOS

3.1 PROTOCOLO VECTOR DISTANCIA

Es un protocolo que utiliza vectores para determinar la distancia de una ruta, estos vectores son
el router de siguiente salto. Este es un protocolo relativamente lento comparado con otros
protocolos de enrutamiento; cuando hago referencia a lento, se refiere a que converge y funciona
de manera ms lenta que los dems tipos de protocolos, por lo que mientras ms grande y
compleja sea la red, ms lento ser el funcionamiento del protocolo. La configuracin de estos
protocolos en relativamente fcil y no requiere de mucho conocimiento, lo cual es una ventaja.
[1]
Los protocolos que usan el algoritmo de vector distancia es RIP y IGRP.

Fig. 1. Tabla de enrutamiento en un algoritmo Vector distacia.[2]

3.1.1 CARACRERISTICAS

Enva la tabla de enrutamiento completa: Al enviar una actualizacin, es enviada la tabla de

enrutamiento completa en forma de broadcast o multicast.
Actualizacin lenta: por ejemplo, RIP: RIP enva actualizaciones cada 30 segundos, salvo que
se d un cambio significativo en su tabla de enrutamiento.
Pueden generar bucles (loops): debido a que se enva la tabla de enrutamiento completa y
que es cada 30 segundos, esto puede provocar que se enven actualizaciones con informacin
incorrecta y se generen bucles.

Para prevenir los bucles se aplican ciertos algoritmos

Distancia mxima (Maximum distance): La distancia mxima para que una ruta sea vlida es
de 16 saltos (hops.
Envenenamiento de ruta (Route poisoning): Una ruta es envenenada al detectarse que esta
no puede ser alcanzada; cuando el router detecta que la ruta no puede ser alcanzada, este
coloca los saltos en 16, de esta forma cuando otro router reciba la actualizacin vera que esta
ruta tiene 16 saltos y la declarar como invalida.
Actualizacin acelerada (triggered update): al detectar que una ruta no se cae, el router enva
inmediatamente una actualizacin indicando que esta ruta se no est, esto lo hace saltando
el tiempo de los 30 segundos para enviar una actualizacin.
Horizonte divido (Split horizon): cuando un router recibe una actualizacin de un router vecino
este router no debe enviar la informacin que recibi por la misma ruta que la recibi. Esto
evita que el los routers enven informacin en actualizaciones a los routers que ya le enviaron
esa informacin, evitando as loops.
 tiempo de espera (hold down timer): Cuando un router enva una actualizacin acelerada a
otro router indicando que una ruta esta down, este router que recibe esa actualizacin no
aceptara actualizaciones con informacin sobre esta ruta por un periodo de tiempo
determinado, de igual forma actualizara a los dems routers para que establezcan el tiempo
durante el cual no recibirn dichas actualizaciones, esto prev de que si una ruta est
actuando de forma intermitente, no se est modificando la tabla de enrutamiento
repetidamente y el procesador de los routers no se sobre cargue.

Ventajas

Configuracin simple
Bajo requerimiento de procesamiento

Desventajas

Convergencia lenta: estos protocolos convergen de manera lenta.

No son escalables: debido a la limitacin de los saltos, estos routers no son eficientes en
redes amplias.
Generan mucho trfico: las actualizaciones son enviadas peridicamente aun despus de que
la red haya convergido, adems en las actualizaciones es enviada una gran parte de la tabla
de enrutamiento.

3.2 ALGORITMO DE BELLMAN-FORD

El algoritmo de Bellman-Ford (algoritmo de Bell-End-Ford) genera el camino ms corto en un

grafo dirigido ponderado (en el que el peso de alguna de las aristas puede ser negativo). El
algoritmo de Dijkstra resuelve este mismo problema en un tiempo menor, pero requiere que los
pesos de las aristas no sean negativos, salvo que el grafo sea dirigido y sin ciclos. Por lo que el
Algoritmo Bellman-Ford normalmente se utiliza cuando hay aristas con peso negativo. Este
algoritmo fue desarrollado por Richard Bellman, Samuel End y Lester Ford.[3]

Modo de funcionamiento [4]

Cada ruteador mantiene una tabla (un vector) que almacena las mejores distancias conocidas a
cada destino y las lneas a usar para cada destino. Se actualizan las tablas intercambiando
informacin con los vecinos.
La tabla de un ruteador almacena una entrada para cada uno de los ruteadores en la subred (los
ruteadores son los ndices). Las entradas almacenan la lnea preferida de salida y una estimacin
del tiempo o la distancia al destino. Se pueden usar mtricas distintas (saltos, retrasos, etc.).
Cada ruteador tiene que medir las distancias a sus vecinos. Por ejemplo, si la mtrica es el retraso,
el ruteador la puede medir usando paquetes de eco.
Cada T msegs los ruteadores intercambian sus tablas con sus vecinos. Un ruteador usa las tablas
de sus vecinos y sus mediciones de las distancias a sus vecinos para calcular una nueva tabla.

Fig. 2. Tabla de enrutamiento en algoritmo de Bellman.[4]

4. EQUIPOS/ RECURSOS/MATERIALES

4.1 Recursos (Accesorios y Material fungible):

Computadora
MATLAB

5. DESARROLLO/PROCEDIMIENTOS

5.1 ALGORITMO BELLMAND-FORD PSEUDOCDIGO

(, , )
[] = 0
{}
[] =
= 1 || 1
(, )
[] > [] + (, )
[] = [] + (, )

Como se observa el algoritmo de Bellman-Ford recibe tres variables principales que son G o la
representacin del grafo, el vrtice inicial y un destino.
El primer paso del algoritmo es la inicializacin la cual consiste en colocar la distancia para el
nodo inicial en cero y para cada nodo v excepto el inicial en infinito o un valor grande que lo
represente.
El algoritmo se encuentra controlado por un for-loop que se ejecuta | V | - 1 iteraciones donde
| V | Es igual al nmero de vrtices de la red.
Bellman-Ford, en cada iteracin para arista sea (u,v) los vrtices de la arista, se realiza un for-
loop por cada vrtice y se realiza lo que se conoce como relajacin, este proceso consiste en
verificar si la distancia actual ms el peso es menor que la distancia adyacente si esta opcin es
verdadera se actualiza la siguiente distancia a la distancia actual ms el peso.

5.2 DIAGRAMA DE FLUJO

 INICIO

G: matriz de pesos
W: nodo destino
S: nodo inicial

distancia(1:n) = inf;
previo(1:n) = inf;
distancia(inicial) = 0;
N= numero de nodos

i=1:N-1

J=1:N

K=1:N

[ ]> [ ]+ ( , )

[ ]= [ ]+ ( , )

K=k+1

J=j+1

i=i+1

Display (distancia)

FIN
5.3 PROGRAMA EN MATLAB DESCRIPCIN Y FUNCIONAMIENTO
5.3.1 DESCRIPCIN DEL CDIGO

En este se programa se ha implementado el algoritmo de Bellmand-Ford primero para que

funcione cada uno de los vrtices como inicial y luego para especificar y cierto par de nodos.
Debido a esto el cdigo empieza preguntando cul de las opciones desea ingresar:

%% Dos formas
fprintf('\n Ingrese T para todos los nodos o C para un par en
especifico \n');
chr_check = input('','s');
check = strcmpi(chr_check,'T'); % comparador

Si la opcin es uno:

Se debe ingresar el nmero de nodos que posee la red, el nmero de aristas y un array con los
pesos, es decir una matriz cuadrada, la cual siempre debe ser de dimensiones n x n en donde n
es el nmero de vrtices que posee el grafo. Cada fila representa el vrtice del cual se parte y
cada columna ser el vrtice al cual llega, el algoritmo se ha probado con diferentes matrices,
pero hay q tomar en cuenta que para un grafo no dirigido la matriz debe ser simtrica.

La matriz ingresada es:

0 1 0 2 0
1 0 3 4 5
= 0 3 0 0 7
2 4 0 0 1
[0 5 7 1 0]

Se puede observar la diagonal de la matriz la cual indica que el peso de ir desde un vrtice
hacia si mismo es igual a cero.

Para graficar la red se utiliza un biograph object y mediante view se observa la grfica.

%Grfico view
ids = {'NODO 1','NODO 2','NODO 3','NODO 4','NODO 5'};
%bg2 = biograph(cm1,ids,'ShowWeights','on');% dirigido
bg2 = biograph(cm1,ids,'ShowArrows','off','ShowWeights','on');% no
dirigido
view(bg2)

Ahora se implementa el algoritmo de Bellmand Ford dentro de un for-loop, el cual empieza en

1 hasta el nmero de nodos, para hacer que cada uno de los nodos funcione como vrtice inicial
y para cada uno se calcule la distancia ms pequea con respecto a los otros nodos:
 Fig. 3. Algortimo implementado

Como se puede observar cada iteracin de p se transformar en la variable source que funcionar
como nodo de partida.

n determina la dimensin de la matriz la cual ser igual al nmero de nodos.

Luego como primer paso del algoritmo se inicializan tanto las distancias como los nodos previos
en infinito, excepto para la distancia source que ser cero.

El primero for recorre desde a hasta n-1 para verificar la distancia con cada uno de los nodos, el
segundo for representa el primer vrtice de la arista, y el tercero el segundo vrtice, dentro de
esto se realiza el proceso de relajacin en donde, se verifica la condicin del algoritmo y se
actualiza la distancia si se cumple la condicin.
Al final se imprime la variable distancia ya que es la que almacena las distancias menores hacia
cada uno de los nodos en forma de vector, en donde la posicin 1 ser la distancia desde el nodo
tomado como source dado por el primer for hasta 1, la posicin dos hasta 2, as para todos los
nodos.

Para la segunda opcin C se especifica un nodo inicial y un nodo destino y la matriz con los pesos
es de forma similar a la descrita anteriormente, se realiza el grfico de la misma forma, en esta
ocasin el algoritmo solo se repite una vez y cuando se obtiene el resultado se procede a imprimir
la ruta obtenida:

ShortestPath = [dest];
traverse = dest;
while (previo(traverse) ~= inicial) % recorre hacia atrs para
encontrar la ruta
ShortestPath = [previo(traverse) ShortestPath];
traverse = previo(traverse);
end
ShortestPath = [previo(traverse) ShortestPath]
%distancia % distancias ms cortas partiendo del vrtice
source a todos los dems vrtices

Adems, en la grfica se colorea la ruta.

5.3.2 FUNCIONAMIENTO

5.3.2.1 FUNCIONAMIENTO FORMA T DE TODOS LOS NODOS

Fig. 4. Grafo

En la figura se puede observar el grfico de los nodos y las aristas, este es un grafo no
dirigido.

Fig. 5. Resultados obtenidos de las rutas ms cortas

 En la grfica se puede observar las distancias ms cortas, partiendo desde los diferentes
vrtices como por ejemplo en la primera desde el vrtice 1, en la primera columna del vector
hacia 1 es igual a cero, hacia el nodo dos es 1, hacia el nodo 3 es 4, hacia el nodo 4 es 2 y
hacia el nodo 5 es 3.

5.3.2.2 FUNCIONAMIENTO FORMA C DE UN CAMINO EN ESPECFICO

Fig. 6. Ruta

En la grfica se puede observar la ruta desde el nodo 5 al nodo 1 ya que son los datos
proporcionado, pero ser el mismo valor viceversa ya que es un grafo no dirigido.

Fig. 7. Resultado de la ruta encontrada

En la grfica se observa los datos proporcionados y la respuesta final la ruta que toma.

6. CONCLUSIONES Y RECOMENDACIONES
 - Se pude concluir que el enrutamiento por vector distancia utiliza el algoritmo de Bellmad-Ford
para obtener la distancia ms corta de un nodo hacia otro, en los routers siempre estn
actualizando la tabla de enrutamiento. En este programa se implementa el algoritmo para
demostrar como se obtiene la distancia ms corta, es importante la forma en la que ingresan los
datos de la red, en el programa se ingresas una matriz de los pesos la cual debe ser simtrica.

7. ANEXOS

7.1 CDIGO DEL PROGRAMA EN MATLAB

%% Algoritmo de BellmanFord en Matlab VECTOR DISTANCIA

%Este programa implementa el algoritmo de ruta ms corta de Bellman-Ford.
% El programa introducir una matriz cuadrada de cualquier tamao n, que
% Indicar el costo de un nodo a otro. Las filas de
% Esta matriz definir el coste "de" un nodo, mientras que el
% Columnas definir el coste "a".
% Input
% 5 9 nmero de vertices y aristas
% [1 2 7; 1 4 2; 2 3 1; 2 4 2; 3 5 4; 4 2 3; 4 3 8; 4 5 5; 5 3 5] Matriz de
% vertices y aristas
% [0 7 0 2 0;0 0 1 2 0;0 0 0 0 5;0 3 8 0 5;0 0 4 0 0] Matriz de pesos
% [0 1 0 2 0;1 0 3 4 5;0 3 0 0 7;2 4 0 0 1;0 5 7 1 0] Matriz de grafo no
% dirigido
% 1 vrtice inicial

clc
clear all
close all

%% Dos formas
fprintf('\n Ingrese T para todos los nodos o C para un par en especifico \n');
chr_check = input('','s');
check = strcmpi(chr_check,'T'); % comparador

if (check==1)
%% Para todos los nodos
% Grafo
N = input(' \n Ingrese el nmero de nodos \n ');% nmero total de vrtices
A = input(' \n Ingrese el nmero de aristas \n ');% nmero total de aristas
cm1 = input (' \n Ingrese los vrtices de las aristas con sus pesos \n '); %
array de vertices y pesos

%Grfico view
%cm = [0 1 1 0 0;1 0 0 1 1;1 0 0 0 0;0 0 0 0 1;1 0 1 0 0]; %Otro grafo
%cm1 = [0 7 0 2 0;0 0 1 2 0;0 0 0 0 5;0 3 8 0 5;0 0 4 0 0];
ids = {'NODO 1','NODO 2','NODO 3','NODO 4','NODO 5'};
%bg2 = biograph(cm1,ids,'ShowWeights','on');% dirigido
bg2 = biograph(cm1,ids,'ShowArrows','off','ShowWeights','on');% no dirigido
view(bg2)

for (p=1:N)
source=p;
%Algoritmo Bellmand Ford
n = size(cm1, 1); % determina la dimension es igual al numero de nodos

distancia(1:n) = inf; % inicializa distancias en infinito

previo(1:n) = inf; % inicializa previo en inifinito
distancia(source) = 0; % distancia de origen en cero
 for (i = 1:n-1)
for (j = 1:n) % Update distance vector if feasible
for (k = 1:n)
if ((distancia(j) + cm1(j,k) < distancia(k)) && (cm1(j,k) ~=
0))
distancia(k) = distancia(j) + cm1(j,k);
previo(k) = j;
end
end
end
end
fprintf(' Distancias ms cortas partiendo del vrtice %d hacia los dems
vrtices \n ',p);
%distancia; % distancias ms cortas partiendo del vrtice source a todos
los dems vrtices
display(distancia)

end

else
%% Para un camino en especifico

inicial = input(' \n Ingrese el nodo inicial \n ');% nodo inicial

dest = input(' \n Ingrese el nodo destino \n ');% nodo destino
cm1 = input (' \n Ingrese los vrtices de las aristas con sus pesos \n ');
% array de vertices y pesos

%Grfico view
%cm = [0 1 1 0 0;1 0 0 1 1;1 0 0 0 0;0 0 0 0 1;1 0 1 0 0]; %Otro grafo
%cm1 = [0 7 0 2 0;0 0 1 2 0;0 0 0 0 5;0 3 8 0 5;0 0 4 0 0];
ids = {'NODO 1','NODO 2','NODO 3','NODO 4','NODO 5'};
%bg2 = biograph(cm1,ids,'ShowWeights','on');grafo dirigido
bg2 = biograph(cm1,ids,'ShowArrows','off','ShowWeights','on');% no dirigido
h = view(bg2)

%Algoritmo Bellmand Ford

n = size(cm1, 1); % determina la dimension es igual al numero de nodos

distancia(1:n) = inf; % inicializa distancias en infinito

previo(1:n) = inf; % inicializa previo en inifinito
distancia(inicial) = 0; % distancia de origen en cero
for (i = 1:n-1)
for (j = 1:n) % Update distance vector if feasible
for (k = 1:n)
if ((distancia(j) + cm1(j,k) < distancia(k)) && (cm1(j,k)
~= 0))
distancia(k) = distancia(j) + cm1(j,k);
previo(k) = j;
end
end
end
end

%Para imprimir la ruta por medio de los nodos

ShortestPath = [dest];
traverse = dest;
 while (previo(traverse) ~= inicial) % recorre hacia atrs para
encontrar la ruta
ShortestPath = [previo(traverse) ShortestPath];
traverse = previo(traverse);
end
ShortestPath = [previo(traverse) ShortestPath]
%distancia % distancias ms cortas partiendo del vrtice source a todos
los dems vrtices

set(h.Nodes(ShortestPath),'Color',[1 0.4 0.4])

edges = getedgesbynodeid(h,get(h.Nodes(ShortestPath),'ID'));
set(edges,'LineColor',[1 0 0])
set(edges,'LineWidth',1.5)

end

8. Bibliografa:

[1] http://theosnews.com/2014/05/tipos-de-protocolos-de-enrutamiento-dinamico-vector-distancia-distance-
vector-estado-de-enlace-link-state-e-hibrido-hybrid/
[2] http://www.cs.virginia.edu/~knabe/iic3512/apuntes_7.html
[3] https://es.wikipedia.org/wiki/Algoritmo_de_Bellman-Ford
[4] http://neo.lcc.uma.es/evirtual/cdd/tutorial/red/bellman.html
https://kulharvijay.files.wordpress.com/2012/09/bellman_ford_algorithm1.pdf
[5] https://jariasf.wordpress.com/2013/01/01/camino-mas-corto-algoritmo-de-bellman-ford/
[6] https://www.mathworks.com/help/bioinfo/ref/graphshortestpath.html
[7] http://www.geeksforgeeks.org/dynamic-programming-set-23-bellman-ford-algorithm/
[8] https://www.mathworks.com/help/bioinfo/ref/biographobject.html