dijkstra_fast 1.4.2 → 1.5.2

data/ext/dijkstra_fast/dijkstra_graph.h

@@ -1,83 +0,0 @@
-#ifndef DIJKSTRA_GRAPH_H
-#define DIJKSTRA_GRAPH_H
-
-#include <ruby.h>
-
-struct VertexListStruct;
-typedef struct VertexListStruct* VertexList;
-
-typedef struct VertexListStruct {
-  struct VertexStruct *vertex;
-  struct VertexListStruct *next;
-} VertexListStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-struct EdgeListStruct;
-typedef struct EdgeListStruct* EdgeList;
-
-typedef struct EdgeListStruct {
-  struct EdgeStruct *edge;
-  struct EdgeListStruct *next;
-} EdgeListStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-struct VertexStruct;
-typedef struct VertexStruct* Vertex;
-
-typedef struct VertexStruct {
-  EdgeList edges;
-  int id;
-  VALUE label;
-} VertexStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-struct EdgeStruct;
-typedef struct EdgeStruct* Edge;
-
-typedef struct EdgeStruct {
-  Vertex source;
-  Vertex dest;
-  int distance;
-} EdgeStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-struct GraphStruct;
-typedef struct GraphStruct* Graph;
-
-typedef struct GraphStruct {
-  unsigned long vertex_count;
-  VertexList vertices;
-  st_table *vertex_lookup;
-} GraphStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-void free_graph(void *data);
-void free_vertex(Vertex n);
-void free_vertex_list(VertexList vertices, void (*free_item)(Vertex));
-void free_edge(Edge e);
-void free_edge_list(EdgeList edges, void (*free_item)(Edge));
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-Vertex add_vertex(Graph g, VALUE label);
-Edge add_edge(Vertex source, Vertex dest, int distance);
-Edge add_edge_with_labels(Graph g, VALUE source_label, VALUE dest_label, int distance);
-Vertex lookup_vertex(Graph g, VALUE label, bool create_if_missing);
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-int shortest_path(Graph g, Vertex source, Vertex dest, VALUE best_path);
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-void Init_dijkstra_graph();
-VALUE dijkstra_graph_allocate(VALUE self);
-VALUE dijkstra_graph_add_edge(VALUE self, VALUE source_label, VALUE dest_label, VALUE distance);
-VALUE dijkstra_graph_shortest_path(VALUE self, VALUE source_label, VALUE dest_label, VALUE best_path);
-
-#endif

data/ext/dijkstra_fast/prioritized_item_list.c

@@ -1,128 +0,0 @@
-#include <prioritized_item_list.h>
-
-PrioritizedItemList make_prioritized_item_list(int capacity) {
-  int i;
-
-  PrioritizedItemList list = malloc(sizeof(PrioritizedItemListStruct));
-  list->priorities = malloc(capacity * sizeof(PrioritizedItem));
-  list->indices = malloc(capacity * sizeof(int));
-  list->capacity = capacity;
-  list->last = capacity - 1;
-  for (i = 0; i < capacity; i++) {
-    list->priorities[i] = malloc(sizeof(PrioritizedItemStruct));
-    list->priorities[i]->item = i;
-    list->priorities[i]->priority = INT_MAX;
-    list->indices[i] = i;
-  }
-  return list;
-}
-
-bool empty_prioritized_item_list(PrioritizedItemList list) {
-  return list->last < 0;
-}
-
-bool in_prioritized_item_list(PrioritizedItemList list, int item) {
-  return list->indices[item] <= list->last;
-}
-
-void swap_prioritized_items(PrioritizedItemList list, int i, int j) {
-  PrioritizedItem tmp = list->priorities[i];
-  list->priorities[i] = list->priorities[j];
-  list->priorities[j] = tmp;
-  list->indices[list->priorities[i]->item] = i;
-  list->indices[list->priorities[j]->item] = j;
-}
-
-void reprioritize_right(PrioritizedItemList list, int i) {
-int orig_i = i;
-  int wi, wj_left, wj_right;
-  int j_left, j_right;
-  wi = list->priorities[i]->priority;
-
-  while (true) {
-    j_left = (i << 1) + 1;
-    j_right = j_left + 1;
-
-    wj_left = j_left <= list->last ? list->priorities[j_left]->priority : INT_MAX;
-    wj_right = j_right <= list->last ? list->priorities[j_right]->priority : INT_MAX;
-
-    if (wj_right < wi && wj_right < wj_left) {
-      swap_prioritized_items(list, i, j_right);
-      i = j_right;
-
-    } else if (wj_left < wi) {
-      swap_prioritized_items(list, i, j_left);
-      i = j_left;
-
-    } else {
-      return;
-    } 
-  }
-}
-
-void reprioritize_left(PrioritizedItemList list, int i) {
-  int wi, wj;
-  int j;
-  wi = list->priorities[i]->priority;
-
-  while (i > 0) {
-    j = (i - 1) >> 1;
-    wj = list->priorities[j]->priority;
-
-    if (wj > wi) {
-      swap_prioritized_items(list, i, j);
-      i = j;
-
-    } else {
-      return;
-    }
-  }
-}
-
-int next_prioritized_item(PrioritizedItemList list) {
-  PrioritizedItem item;
-
-  if (empty_prioritized_item_list(list)) {
-    return -1;
-  }
-
-  item = list->priorities[0];
-  swap_prioritized_items(list, 0, list->last);
-  list->last--;
-  reprioritize_right(list, 0);
-
-  return item->item;
-}
-
-void update_prioritized_item(PrioritizedItemList list, int item, int priority) {
-  int i = list->indices[item];
-  list->priorities[i]->priority = priority;
-
-  if (i <= list->last) {
-    reprioritize_left(list, i);
-  }
-}
-
-int get_priority(PrioritizedItemList list, int item) {
-  int index = list->indices[item];
-  return list->priorities[index]->priority;
-}
-
-// For debugging only
-void print_prioritized_item_list(PrioritizedItemList list) {
-  for (int i = 0; i <= list->last; i++) {
-    if (i > 0) printf(", ");
-    printf("%d (%d)", list->priorities[i]->item, list->priorities[i]->priority);
-  }
-  printf("\n");
-}
-
-void free_prioritized_item_list(PrioritizedItemList list) {
-  for (int i = 0; i < list->capacity; i++) {
-    free(list->priorities[i]);
-  }
-
-  free(list->priorities);
-  free(list->indices);
-  free(list);
-}

data/ext/dijkstra_fast/prioritized_item_list.h

@@ -1,39 +0,0 @@
-#ifndef PRIORITIZED_ITEM_LIST_H
-#define PRIORITIZED_ITEM_LIST_H
-
-#include <ruby.h>
-
-struct PrioritizedItemStruct;
-typedef struct PrioritizedItemStruct* PrioritizedItem;
-
-typedef struct PrioritizedItemStruct {
-  int item;
-  int priority;
-} PrioritizedItemStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-struct PrioritizedItemListStruct;
-typedef struct PrioritizedItemListStruct* PrioritizedItemList;
-
-typedef struct PrioritizedItemListStruct {
-  PrioritizedItem *priorities;
-  int *indices;
-  int capacity;
-  int last;
-} PrioritizedItemListStruct;
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-PrioritizedItemList make_prioritized_item_list(int capacity);
-bool empty_prioritized_item_list(PrioritizedItemList list);
-bool in_prioritized_item_list(PrioritizedItemList list, int item);
-int next_prioritized_item(PrioritizedItemList list);
-void update_prioritized_item(PrioritizedItemList list, int item, int priority);
-void print_prioritized_item_list(PrioritizedItemList list);
-int get_priority(PrioritizedItemList list, int item);
-void free_prioritized_item_list(PrioritizedItemList list);
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-#endif

data/lib/dijkstra_fast/best_path.rb

@@ -1,17 +0,0 @@
-module DijkstraFast
-  ##
-  # The "best path" from applying Dijkstra's algorithm contains both the ordered
-  # list of nodes travelled as well as the total distance travelled.
-  ##
-  class BestPath
-
-    attr_reader :path
-    attr_accessor :distance
-
-    def initialize
-      @path = []
-      @distance = 0
-    end
-
-  end
-end