pgr_bellmanFord - Experimental

pgr_bellmanFord — Devuelve la o las ruta(s) más cortas mediante el algoritmo Bellman-Ford. En particular, el algoritmo Bellman-Ford implementado por Boost.Graph.

_images/boost-inside.jpeg

Adentro: Boost Graph

Advertencia

Posible bloqueo del servidor

  • Estas funciones pueden crear un bloqueo del servidor

Advertencia

Funciones experimentales

  • No son oficialmente de la versión actual.
  • Es probable que oficialmente no formen parte de la siguiente versión:
    • Las funciones no podrían hacer uso de ANY-INTEGER ni ANY-NUMERICAL
    • El nombre puede cambiar.
    • La firma (declaración de funciones) podría cambiar.
    • La funcionalidad puede cambiar.
    • Las pruebas de pgTap pueden estar ausentes.
    • Posiblemente necesite codificación c/c++.
    • Puede haber carencia de documentación.
    • Hay documentación que, en dado caso, podría ser necesario reescribir.
    • Ejemplos de documentación que puede ser necesario generar automáticamente.
    • Puede ser necesaria más retroalimentación por parte de la comunidad.
    • Puede depender de una función propuesta de pgRouting.
    • Podría depender de una función obsoleta de pgRouting

Disponibilidad

  • Versión 3.0.0
    • Nueva función experimental

Soporte

Descripción

El algoritmo de Bellman-Ford, lleva el nombre de Richard Bellman y Lester Ford, quienes lo publicaron por primera vez en 1958 y 1956, respectivamente. Es un algoritmo de búsqueda de grafos que calcula las rutas más cortas desde un vértice inicial (start_vid) hasta un vértice final (end_vid) en un grafo donde algunos de los pesos de borde pueden ser números negativos. Aunque es más versátil, es más lento que el algoritmo de Dijkstra/ Esta implementación se puede utilizar con un grafo dirigido y un grafo no dirigido.

Las principales características son:
  • El proceso es válido para aristas con grosores de arista positivos y negativos.
  • Valores son regresados cuando hay un camino.
    • Cuando el vértice inicial y el vértice final son los mismos, no hay ruta. El agg_cost sería 0.
    • Cuando el vértice inicial y el vértice final son diferentes, y existe una ruta entre ellos sin tener un ciclo negativo. El agg_cost sería un valor finito que indica la distancia más corta entre ellos.
    • Cuando el vértice inicial y el vértice final son diferentes y existe una ruta entre ellos, pero contiene un ciclo negativo. En tal caso, agg_cost para esos vértices siguen disminuyendo además, por lo tanto agg_cost no se puede definir para ellos.
    • Cuando el vértice inicial y el vértice final son diferentes y no hay ruta. El agg_cost es \(\infty\).
  • Para fines de optimización, se omite cualquier valor duplicado en start_vids o end_vids.
  • Los valores regresados se ordenan:
    • start_vid ascendente
    • end_vid ascendente
  • Tiempo de ejecución \(O(| start\_vids | * ( V * E))\)

Firmas

Resumen

pgr_bellmanFord(edges_sql, from_vid,  to_vid  [, directed])
pgr_bellmanFord(edges_sql, from_vid,  to_vids [, directed])
pgr_bellmanFord(edges_sql, from_vids, to_vid  [, directed])
pgr_bellmanFord(edges_sql, from_vids, to_vids [, directed])

RETURNS SET OF (seq, path_seq, node, edge, cost, agg_cost)
OR EMPTY SET

Uso de valores predeterminados

pgr_bellmanFord(TEXT edges_sql, BIGINT start_vid, BIGINT end_vid)
RETURNS SET OF (seq, path_seq, node, edge, cost, agg_cost)
OR EMPTY SET
Ejemplo:Del vértice \(2\) al :3 en un grafo dirigido 
SELECT * FROM pgr_bellmanFord(
    'SELECT id, source, target, cost, reverse_cost FROM edge_table',
    2, 3
);
 seq | path_seq | node | edge | cost | agg_cost
-----+----------+------+------+------+----------
   1 |        1 |    2 |    4 |    1 |        0
   2 |        2 |    5 |    8 |    1 |        1
   3 |        3 |    6 |    9 |    1 |        2
   4 |        4 |    9 |   16 |    1 |        3
   5 |        5 |    4 |    3 |    1 |        4
   6 |        6 |    3 |   -1 |    0 |        5
(6 rows)

Uno a Uno

pgr_bellmanFord(edges_sql, from_vid,  to_vid  [, directed])
RETURNS SET OF (seq, path_seq, node, edge, cost, agg_cost)
OR EMPTY SET
Ejemplo:Del vértice \(2\) al vértice \(3\) en un grafo no dirigido 
SELECT * FROM pgr_bellmanFord(
    'SELECT id, source, target, cost, reverse_cost FROM edge_table',
    2, 3,
    FALSE
);
 seq | path_seq | node | edge | cost | agg_cost
-----+----------+------+------+------+----------
   1 |        1 |    2 |    2 |    1 |        0
   2 |        2 |    3 |   -1 |    0 |        1
(2 rows)

Uno a muchos

pgr_bellmanFord(edges_sql, from_vid,  to_vids [, directed])
RETURNS SET OF (seq, path_seq, end_vid, node, edge, cost, agg_cost)
OR EMPTY SET
Ejemplo:Desde el vértice \(2\) a los vértices \(\{ 3, 5\}\) en un grafo no dirigido 
SELECT * FROM pgr_bellmanFord(
    'SELECT id, source, target, cost, reverse_cost FROM edge_table',
    2, ARRAY[3,5],
    FALSE
);
 seq | path_seq | end_vid | node | edge | cost | agg_cost
-----+----------+---------+------+------+------+----------
   1 |        1 |       3 |    2 |    2 |    1 |        0
   2 |        2 |       3 |    3 |   -1 |    0 |        1
   3 |        1 |       5 |    2 |    4 |    1 |        0
   4 |        2 |       5 |    5 |   -1 |    0 |        1
(4 rows)

Muchos a Uno

pgr_bellmanFord(edges_sql, from_vids, to_vid  [, directed])
RETURNS SET OF (seq, path_seq, start_vid, node, edge, cost, agg_cost)
OR EMPTY SET
Ejemplo:De los vértices \(\{2, 11\}\) to vertex \(5\) on a directed graph 
SELECT * FROM pgr_bellmanFord(
    'SELECT id, source, target, cost, reverse_cost FROM edge_table',
    ARRAY[2,11], 5
);
 seq | path_seq | start_vid | node | edge | cost | agg_cost
-----+----------+-----------+------+------+------+----------
   1 |        1 |         2 |    2 |    4 |    1 |        0
   2 |        2 |         2 |    5 |   -1 |    0 |        1
   3 |        1 |        11 |   11 |   13 |    1 |        0
   4 |        2 |        11 |   12 |   15 |    1 |        1
   5 |        3 |        11 |    9 |    9 |    1 |        2
   6 |        4 |        11 |    6 |    8 |    1 |        3
   7 |        5 |        11 |    5 |   -1 |    0 |        4
(7 rows)

Muchos a Muchos

pgr_bellmanFord(edges_sql, from_vids, to_vids [, directed])
RETURNS SET OF (seq, path_seq, start_vid, end_vid, node, edge, cost, agg_cost)
OR EMPTY SET
Ejemplo:De los vértices​ \(\{2, 11\}\) a los vértices \(\{3, 5\}\) en un grafo no dirigido 
SELECT * FROM pgr_bellmanFord(
    'SELECT id, source, target, cost, reverse_cost FROM edge_table',
    ARRAY[2,11], ARRAY[3,5]
);
 seq | path_seq | start_vid | end_vid | node | edge | cost | agg_cost
-----+----------+-----------+---------+------+------+------+----------
   1 |        1 |         2 |       3 |    2 |    4 |    1 |        0
   2 |        2 |         2 |       3 |    5 |    8 |    1 |        1
   3 |        3 |         2 |       3 |    6 |    9 |    1 |        2
   4 |        4 |         2 |       3 |    9 |   16 |    1 |        3
   5 |        5 |         2 |       3 |    4 |    3 |    1 |        4
   6 |        6 |         2 |       3 |    3 |   -1 |    0 |        5
   7 |        1 |         2 |       5 |    2 |    4 |    1 |        0
   8 |        2 |         2 |       5 |    5 |   -1 |    0 |        1
   9 |        1 |        11 |       3 |   11 |   13 |    1 |        0
  10 |        2 |        11 |       3 |   12 |   15 |    1 |        1
  11 |        3 |        11 |       3 |    9 |   16 |    1 |        2
  12 |        4 |        11 |       3 |    4 |    3 |    1 |        3
  13 |        5 |        11 |       3 |    3 |   -1 |    0 |        4
  14 |        1 |        11 |       5 |   11 |   13 |    1 |        0
  15 |        2 |        11 |       5 |   12 |   15 |    1 |        1
  16 |        3 |        11 |       5 |    9 |    9 |    1 |        2
  17 |        4 |        11 |       5 |    6 |    8 |    1 |        3
  18 |        5 |        11 |       5 |    5 |   -1 |    0 |        4
(18 rows)

Parámetros

Descripción de los parámetros de las firmas (declaraciones de funciones)

Parámetro Tipo Valores predeterminados Descripción
edges_sql TEXT   Consulta SQL como se describió anteriormente.
start_vid BIGINT   Identificador del vértice inicial de la ruta.
start_vids ARRAY[BIGINT]   Arreglo de identificadores de vértices iniciales.
end_vid BIGINT   Identificador del vértice final de la ruta.
end_vids ARRAY[BIGINT]   Arreglo de identificadores de vértices finales.
dirigido BOOLEAN true
  • Cuando true el gráfo se considera Dirigido
  • Cuando false el gráfo se considera No Dirigido

Consulta interna

Columna Tipo Valores predeterminados Descripción
id ANY-INTEGER   Identificador de la arista.
origen ANY-INTEGER   Identificador del primer punto final en el vértice de la arista.
objetivo ANY-INTEGER   Identificador del segundo punto final en el vértice de la arista.
costo ANY-NUMERICAL  

Peso de la arista (source, target)

  • Cuando es negativo: la arista (source, target) no existe, por lo tanto no es parte del grafo.
reverse_cost ANY-NUMERICAL -1

Peso de la arista (target, source),

  • En caso negativo: la arista (target, source) no existe, por lo tanto no es parte del grafo.

Donde:

ANY-INTEGER:SMALLINT, INTEGER, BIGINT
ANY-NUMERICAL:SMALLINT, INTEGER, BIGINT, REAL, FLOAT

Columnas de Resultados

Devuelve el conjunto de (seq, path_seq [, start_vid] [, end_vid], node, edge, cost, agg_cost)

Columna Tipo Descripción
seq INT Valor secuencial a partir de 1.
path_seq INT Posición relativa en la ruta. Tiene el valor 1 para el principio de una ruta.
start_vid BIGINT

Identificador del vértice inicial. Se devuelve cuando hay varias vetrices iniciales en la consulta.
end_vid BIGINT

Identificador del vértice final. Se devuelve cuando hay varios vértices finales en la consulta.
nodo BIGINT Identificador del nodo en la ruta de start_vid a end_vid.
arista BIGINT Identificador del borde utilizado para ir del nodo al siguiente nodo de la secuencia de ruta. -1 para el último nodo de la ruta.
costo FLOAT Costo de desplazamiento desde node usando `` edge`` hasta el siguiente nodo en la secuencia de ruta.
agg_cost FLOAT Coste agregado de start_v to node.

Ver también

Índices y tablas