gameplan 0.0.1 → 0.0.2

data/.gitignore

@@ -1,2 +1,3 @@
 site
-*.rb
+*.rb
+pkg

data/lib/gameplan/frontend/public/js/Curry-1.0.1.js

@@ -0,0 +1,29 @@
+/**
+ * Curry - Function currying
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 10/4/2008
+ *
+ * @author Ariel Flesler
+ * @version 1.0.1
+ */
+
+function curry( fn ){
+	return function(){
+		var args = curry.args(arguments),
+			master = arguments.callee,
+			self = this;
+
+		return args.length >= fn.length ? fn.apply(self,args) :	function(){
+			return master.apply( self, args.concat(curry.args(arguments)) );
+		};
+	};
+};
+
+curry.args = function( args ){
+	return Array.prototype.slice.call(args);
+};
+
+Function.prototype.curry = function(){
+	return curry(this);
+};

data/lib/gameplan/frontend/public/js/app.js

@@ -0,0 +1,112 @@
+var redraw;
+
+window.onload = function() {
+  var width  = 400;//$('#canvas').width();
+  var height = 300;//$('#canvas').height() - 100;
+
+  /* Showcase of the Bellman-Ford search algorithm finding shortest paths
+     from one point to every node */
+
+  /* We need to write a new node renderer function to display the computed
+     distance.
+     (the Raphael graph drawing implementation of Dracula can draw this shape,
+     please consult the RaphaelJS reference for details http://raphaeljs.com/) */
+  var render = function(r, n) {
+    frame = r.rect(n.point[0] - 30, n.point[1] - 13, 60, 44);
+    frame.attr({
+        'fill': '#feb'/*, r : '12px'*/,
+        'stroke-width' : (n.distance === 0 ? '3px' : '1px')
+      });
+    /* the Raphael set is obligatory, containing all you want to display */
+    var set = r.set()
+      .push(
+        frame,
+        /* custom objects go here */
+        r.text(n.point[0], n.point[1] + 10, (n.label || n.id)
+          + "\n(" + (n.distance === undefined ? 'Infinity' : n.distance) + ')')
+      );
+    return set;
+  };
+
+  var g = new Graph();
+
+  /* modify the edge creation to attach random weights */
+  g.edgeFactory.build = function(source, target) {
+    var e = jQuery.extend(true, {}, this.template);
+    e.source = source;
+    e.target = target;
+    e.style.label = e.weight = Math.floor(Math.random() * 10) + 1;
+    return e;
+  }
+
+  /* creating nodes and passing the new renderer function to overwrite the default one */
+  g.addNode('New York', { render : render }); // TODO add currying support for nicer code
+  g.addNode('Berlin'  , { render : render });
+  g.addNode('Tel Aviv', { render : render });
+  g.addNode('Tokyo'   , { render : render });
+  g.addNode('Roma'    , { render : render });
+  g.addNode('Madrid'  , { render : render });
+
+  /* connections */
+  g.addEdge("Tokyo"   , "Tel Aviv");
+  /*, {weight:9, directed: true, stroke : "#bfa"}*/
+  // also supports directed graphs, but currently doesn't look that nice
+  g.addEdge("Tokyo"   , "New York");
+  g.addEdge("Tokyo"   , "Berlin");
+  g.addEdge("Tel Aviv", "Berlin");
+  g.addEdge("Tel Aviv", "New York");
+  g.addEdge("Tel Aviv", "Roma");
+  g.addEdge("Roma"    , "New York");
+  g.addEdge("Berlin"  , "New York");
+  g.addEdge("Madrid"  , "New York");
+  g.addEdge("Madrid"  , "Roma");
+  g.addEdge("Madrid"  , "Tokyo");
+
+  /* random edge weights (our undirected graph is modelled as a bidirectional graph) */
+  /*    for(e in g.edges)
+        if(g.edges[e].backedge != undefined) {
+        g.edges[e].weight = Math.floor(Math.random()*10) + 1;
+        g.edges[e].backedge.weight = g.edges[e].weight;
+        }
+        */
+  /* layout the graph using the Spring layout implementation */
+  var layouter = new Graph.Layout.Spring(g);
+
+  /* draw the graph using the RaphaelJS draw implementation */
+
+  /* calculating the shortest paths via Bellman Ford */
+  //bellman_ford(g, g.nodes["Berlin"]);
+
+  /* calculating the shortest paths via Dijkstra */
+  dijkstra(g, g.nodes["Berlin"]);
+
+  /* calculating the shortest paths via Floyd-Warshall */
+  //floyd_warshall(g, g.nodes['Berlin']);
+
+
+  /* colourising the shortest paths and setting labels */
+  for(e in g.edges) {
+    if(g.edges[e].target.predecessor === g.edges[e].source
+        || g.edges[e].source.predecessor === g.edges[e].target)
+    {
+      g.edges[e].style.stroke = '#bfa';
+      g.edges[e].style.fill   = '#56f';
+    } else {
+      g.edges[e].style.stroke = '#aaa';
+    }
+  }
+
+  var renderer = new Graph.Renderer.Raphael('canvas', g, width, height);
+
+  redraw = function() {
+    layouter.layout();
+    renderer.draw();
+  };
+
+  /*    var pos=0;
+        step = function(dir) {
+        pos+=dir;
+        var renderer = new Graph.Renderer.Raphael('canvas', g.snapshots[pos], width, height);
+        renderer.draw();
+        };*/
+};

data/lib/gameplan/frontend/public/js/dracula_algorithms.js

@@ -0,0 +1,616 @@
+/*
+ * Various algorithms and data structures, licensed under the MIT-license.
+ * (c) 2010 by Johann Philipp Strathausen <strathausen@gmail.com>
+ * http://strathausen.eu
+ *
+ */
+
+
+
+/*
+        Bellman-Ford
+
+    Path-finding algorithm, finds the shortest paths from one node to all nodes.
+
+
+        Complexity
+
+    O( |E| · |V| ), where E = edges and V = vertices (nodes)
+
+
+        Constraints
+
+    Can run on graphs with negative edge weights as long as they do not have
+    any negative weight cycles.
+
+ */
+function bellman_ford(g, source) {
+  var i, l;
+
+  /* STEP 1: initialisation */
+  for(var n in g.nodes) {
+    g.nodes[n].distance = Infinity;
+  }
+  /* predecessors are implicitly zero */
+  source.distance = 0;
+
+  step("Initially, all distances are infinite and all predecessors are null.");
+
+  /* STEP 2: relax each edge (this is at the heart of Bellman-Ford) */
+  /* repeat this for the number of nodes minus one */
+  for(i = 1, l = g.nodes.length; i < l; i++)
+    /* for each edge */
+    for(var e in g.edges) {
+      var edge = g.edges[e];
+      if(edge.source.distance + edge.weight < edge.target.distance) {
+        step("Relax edge between " + edge.source.id + " and " + edge.target.id + ".");
+        edge.target.distance = edge.source.distance + edge.weight;
+        edge.target.predecessor = edge.source;
+      }
+      // Added by Jake Stothard (Needs to be tested)
+      //if(!edge.style.directed) {
+        //if(edge.target.distance + edge.weight < edge.source.distance) {
+          //g.snapShot("Relax edge between " + edge.target.id + " and " + edge.source.id + ".");
+          //edge.source.distance = edge.target.distance + edge.weight;
+          //edge.source.predecessor = edge.target;
+        //}
+      //}
+    }
+  step("Ready.");
+
+  /* STEP 3: TODO Check for negative cycles */
+  /* For now we assume here that the graph does not contain any negative
+     weights cycles. (this is left as an excercise to the reader[tm]) */
+}
+
+
+
+/*
+   Path-finding algorithm Dijkstra
+
+   - worst-case running time is O((|E| + |V|) · log |V| ) thus better than
+     Bellman-Ford for sparse graphs (with less edges), but cannot handle
+     negative edge weights
+ */
+function dijkstra(g, source) {
+
+  /* initially, all distances are infinite and all predecessors are null */
+  for(var n in g.nodes)
+    g.nodes[n].distance = Infinity;
+  /* predecessors are implicitly null */
+
+  g.snapShot("Initially, all distances are infinite and all predecessors are null.");
+
+  source.distance = 0;
+  /* set of unoptimized nodes, sorted by their distance (but a Fibonacci heap
+     would be better) */
+  var q = new BinaryMinHeap(g.nodes, "distance");
+
+  /* pointer to the node in focus */
+  var node;
+
+  /* get the node with the smallest distance
+     as long as we have unoptimized nodes. q.min() can have O(log n). */
+  while(q.min() != undefined) {
+    /* remove the latest */
+    node = q.extractMin();
+    node.optimized = true;
+
+    /* no nodes accessible from this one, should not happen */
+    if(node.distance == Infinity)
+      throw "Orphaned node!";
+
+    /* for each neighbour of node */
+    for(e in node.edges) {
+      var other = (node == node.edges[e].target) ? node.edges[e].source : node.edges[e].target;
+
+      if(other.optimized)
+        continue;
+
+      /* look for an alternative route */
+      var alt = node.distance + node.edges[e].weight;
+
+      /* update distance and route if a better one has been found */
+      if (alt < other.distance) {
+
+        /* update distance of neighbour */
+        other.distance = alt;
+
+        /* update priority queue */
+        q.heapify();
+
+        /* update path */
+        other.predecessor = node;
+        g.snapShot("Enhancing node.")
+      }
+    }
+  }
+}
+
+
+/* All-Pairs-Shortest-Paths */
+/* Runs at worst in O(|V|³) and at best in Omega(|V|³) :-)
+   complexity Sigma(|V|²) */
+/* This implementation is not yet ready for general use, but works with the
+   Dracula graph library. */
+function floyd_warshall(g, source) {
+
+  /* Step 1: initialising empty path matrix (second dimension is implicit) */
+  var path = [];
+  var next = [];
+  var n = g.nodes.length;
+
+  /* construct path matrix, initialize with Infinity */
+  for(j in g.nodes) {
+    path[j] = [];
+    next[j] = [];
+    for(i in g.nodes)
+      path[j][i] = j == i ? 0 : Infinity;
+  }
+
+  /* initialize path with edge weights */
+  for(e in g.edges)
+    path[g.edges[e].source.id][g.edges[e].target.id] = g.edges[e].weight;
+
+  /* Note: Usually, the initialisation is done by getting the edge weights
+     from a node matrix representation of the graph, not by iterating through
+     a list of edges as done here. */
+
+  /* Step 2: find best distances (the heart of Floyd-Warshall) */
+  for(k in g.nodes){
+    for(i in g.nodes) {
+      for(j in g.nodes)
+        if(path[i][j] > path[i][k] + path[k][j]) {
+          path[i][j] = path[i][k] + path[k][j];
+          /* Step 2.b: remember the path */
+          next[i][j] = k;
+        }
+    }
+  }
+
+  /* Step 3: Path reconstruction, get shortest path */
+  function getPath(i, j) {
+    if(path[i][j] == Infinity)
+      throw "There is no path.";
+    var intermediate = next[i][j];
+    if(intermediate == undefined)
+      return null;
+    else
+      return getPath(i, intermediate)
+        .concat([intermediate])
+        .concat(getPath(intermediate, j));
+  }
+
+  /* TODO use the knowledge, e.g. mark path in graph */
+}
+
+/*
+   Ford-Fulkerson
+
+    Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
+    graph from source to sink.
+
+
+        Complexity
+
+    O(E * max(f)), max(f) being the maximum flow
+
+
+        Description
+
+    As long as there is an open path through the residual graph, send the
+    minimum of the residual capacities on the path.
+
+
+        Constraints
+
+    The algorithm works only if all weights are integers. Otherwise it is
+    possible that the Ford–Fulkerson algorithm will not converge to the maximum
+    value.
+
+
+        Input
+
+    g - Graph object
+    s - Source ID
+    t - Target (sink) ID
+
+
+        Output
+
+    Maximum flow from Source s to Target t
+
+ */
+/*
+        Edmonds-Karp
+
+    Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
+    graph from source to sink. An implementation of the Ford-Fulkerson
+    algorithm.
+
+
+        Complexity
+
+    O(|V|*|E|²)
+
+
+        Input
+
+    g - Graph object (with node and edge lists, capacity is a property of edge)
+    s - source ID
+    t - sink ID
+
+ */
+function edmonds_karp(g, s, t) {
+
+}
+
+/*
+   A simple binary min-heap serving as a priority queue
+   - takes an array as the input, with elements having a key property
+   - elements will look like this:
+        {
+            key: "... key property ...",
+            value: "... element content ..."
+        }
+    - provides insert(), min(), extractMin() and heapify()
+    - example usage (e.g. via the Firebug or Chromium console):
+        var x = {foo: 20, hui: "bla"};
+        var a = new BinaryMinHeap([x,{foo:3},{foo:10},{foo:20},{foo:30},{foo:6},{foo:1},{foo:3}],"foo");
+        console.log(a.extractMin());
+        console.log(a.extractMin());
+        x.foo = 0; // update key
+        a.heapify(); // call this always after having a key updated
+        console.log(a.extractMin());
+        console.log(a.extractMin());
+    - can also be used on a simple array, like [9,7,8,5]
+ */
+function BinaryMinHeap(array, key) {
+
+  /* Binary tree stored in an array, no need for a complicated data structure */
+  var tree = [];
+
+  var key = key || 'key';
+
+  /* Calculate the index of the parent or a child */
+  var parent = function(index) { return Math.floor((index - 1)/2); };
+  var right = function(index) { return 2 * index + 2; };
+  var left = function(index) { return 2 * index + 1; };
+
+  /* Helper function to swap elements with their parent
+     as long as the parent is bigger */
+  function bubble_up(i) {
+    var p = parent(i);
+    while((p >= 0) && (tree[i][key] < tree[p][key])) {
+      /* swap with parent */
+      tree[i] = tree.splice(p, 1, tree[i])[0];
+      /* go up one level */
+      i = p;
+      p = parent(i);
+    }
+  }
+
+  /* Helper function to swap elements with the smaller of their children
+     as long as there is one */
+  function bubble_down(i) {
+    var l = left(i);
+    var r = right(i);
+
+    /* as long as there are smaller children */
+    while(tree[l] && (tree[i][key] > tree[l][key]) || tree[r] && (tree[i][key] > tree[r][key])) {
+
+      /* find smaller child */
+      var child = tree[l] ? tree[r] ? tree[l][key] > tree[r][key] ? r : l : l : l;
+
+      /* swap with smaller child with current element */
+      tree[i] = tree.splice(child, 1, tree[i])[0];
+
+      /* go up one level */
+      i = child;
+      l = left(i);
+      r = right(i);
+    }
+  }
+
+  /* Insert a new element with respect to the heap property
+     1. Insert the element at the end
+     2. Bubble it up until it is smaller than its parent */
+  this.insert = function(element) {
+
+    /* make sure there's a key property */
+    (element[key] == undefined) && (element = {key:element});
+
+        /* insert element at the end */
+        tree.push(element);
+
+        /* bubble up the element */
+        bubble_up(tree.length - 1);
+    }
+
+    /* Only show us the minimum */
+    this.min = function() {
+        return tree.length == 1 ? undefined : tree[0];
+    }
+
+    /* Return and remove the minimum
+       1. Take the root as the minimum that we are looking for
+       2. Move the last element to the root (thereby deleting the root)
+       3. Compare the new root with both of its children, swap it with the
+          smaller child and then check again from there (bubble down)
+    */
+    this.extractMin = function() {
+        var result = this.min();
+
+        /* move the last element to the root or empty the tree completely */
+        /* bubble down the new root if necessary */
+        (tree.length == 1) && (tree = []) || (tree[0] = tree.pop()) && bubble_down(0);
+
+        return result;
+    }
+
+    /* currently unused, TODO implement */
+    this.changeKey = function(index, key) {
+        throw "function not implemented";
+    }
+
+    this.heapify = function() {
+        for(var start = Math.floor((tree.length - 2) / 2); start >= 0; start--) {
+            bubble_down(start);
+        }
+    }
+
+    /* insert the input elements one by one only when we don't have a key property (TODO can be done more elegant) */
+    for(i in (array || []))
+        this.insert(array[i]);
+}
+
+
+
+/*
+    Quick Sort:
+        1. Select some random value from the array, the median.
+        2. Divide the array in three smaller arrays according to the elements
+           being less, equal or greater than the median.
+        3. Recursively sort the array containg the elements less than the
+           median and the one containing elements greater than the median.
+        4. Concatenate the three arrays (less, equal and greater).
+        5. One or no element is always sorted.
+    TODO: This could be implemented more efficiently by using only one array object and several pointers.
+*/
+function quickSort(arr) {
+  /* recursion anchor: one element is always sorted */
+  if(arr.length <= 1) return arr;
+  /* randomly selecting some value */
+  var median = arr[Math.floor(Math.random() * arr.length)];
+  var arr1 = [], arr2 = [], arr3 = [];
+  for(var i in arr) {
+    arr[i] < median && arr1.push(arr[i]);
+    arr[i] == median && arr2.push(arr[i]);
+    arr[i] > median && arr3.push(arr[i]);
+  }
+  /* recursive sorting and assembling final result */
+  return quickSort(arr1).concat(arr2).concat(quickSort(arr3));
+}
+
+/*
+   Selection Sort:
+   1. Select the minimum and remove it from the array
+   2. Sort the rest recursively
+   3. Return the minimum plus the sorted rest
+   4. An array with only one element is already sorted
+   */
+function selectionSort(arr) {
+  /* recursion anchor: one element is always sorted */
+  if(arr.length == 1) return arr;
+  var minimum = Infinity;
+  var index;
+  for(var i in arr) {
+    if(arr[i] < minimum) {
+      minimum = arr[i];
+      index = i; /* remember the minimum index for later removal */
+    }
+  }
+  /* remove the minimum */
+  arr.splice(index, 1);
+  /* assemble result and sort recursively (could be easily done iteratively as well)*/
+  return [minimum].concat(selectionSort(arr));
+}
+
+/*
+   Merge Sort:
+   1. Cut the array in half
+   2. Sort each of them recursively
+   3. Merge the two sorted arrays
+   4. An array with only one element is considered sorted
+
+*/
+function mergeSort(arr) {
+  /* merges two sorted arrays into one sorted array */
+  function merge(a, b) {
+    /* result set */
+    var c = [];
+    /* as long as there are elements in the arrays to be merged */
+    while(a.length > 0 || b.length > 0){
+      /* are there elements to be merged, if yes, compare them and merge */
+      var n = a.length > 0 && b.length > 0 ? a[0] < b[0] ? a.shift() : b.shift() : b.length > 0 ? b.shift() : a.length > 0 ? a.shift() : null;
+      /* always push the smaller one onto the result set */
+      n != null && c.push(n);
+    }
+    return c;
+  }
+  /* this mergeSort implementation cuts the array in half, wich should be fine with randomized arrays, but introduces the risk of a worst-case scenario */
+  median = Math.floor(arr.length / 2);
+  var part1 = arr.slice(0, median); /* for some reason it doesn't work if inserted directly in the return statement (tried so with firefox) */
+  var part2 = arr.slice(median - arr.length);
+  return arr.length <= 1 ? arr : merge(
+      mergeSort(part1), /* first half */
+      mergeSort(part2) /* second half */
+      );
+}
+
+/* Balanced Red-Black-Tree */
+function RedBlackTree(arr) {
+
+}
+
+function BTree(arr) {
+
+}
+
+function NaryTree(n, arr) {
+
+}
+
+/**
+ * Knuth-Morris-Pratt string matching algorithm - finds a pattern in a text.
+ * FIXME: Doesn't work correctly yet.
+ */
+function kmp(p, t) {
+
+  /**
+   * PREFIX, OVERLAP or FALIURE function for KMP. Computes how many iterations
+   * the algorithm can skip after a mismatch.
+   *
+   * @input p - pattern (string)
+   * @result array of skippable iterations
+   */
+  function prefix(p) {
+    /* pi contains the computed skip marks */
+    var pi = [0], k = 0;
+    for(q = 1; q < p.length; q++) {
+      while(k > 0 && (p.charAt(k) != p.charAt(q)))
+        k = pi[k-1];
+
+      (p.charAt(k) == p.charAt(q)) && k++;
+
+      pi[q] = k;
+    }
+    return pi;
+  }
+
+  /* The actual KMP algorithm starts here. */
+
+  var pi = prefix(p), q = 0, result = [];
+
+  for(var i = 0; i < t.length; i++) {
+    /* jump forward as long as the character doesn't match */
+    while((q > 0) && (p.charAt(q) != t.charAt(i)))
+      q = pi[q];
+
+    (p.charAt(q) == t.charAt(i)) && q++;
+
+    (q == p.length) && result.push(i - p.length) && (q = pi[q]);
+  }
+
+  return result;
+}
+
+/* step for algorithm visualisation */
+function step(comment, funct) {
+  //wait for input
+  //display comment (before or after waiting)
+  //    next.wait();
+  /* execute callback function */
+  funct();
+}
+
+/**
+ * Curry - Function currying
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 10/4/2008
+ *
+ * @author Ariel Flesler
+ * @version 1.0.1
+ */
+function curry( fn ){
+  return function(){
+    var args = curry.args(arguments),
+        master = arguments.callee,
+        self = this;
+
+    return args.length >= fn.length ? fn.apply(self,args) :	function(){
+      return master.apply( self, args.concat(curry.args(arguments)) );
+    };
+  };
+};
+
+curry.args = function( args ){
+  return Array.prototype.slice.call(args);
+};
+
+Function.prototype.curry = function(){
+  return curry(this);
+};
+
+/**
+ * Node ID Sort
+ *
+ * Sort a directed graph by the IDs useful for limited circumstances
+ * Assumes node.id is an integer. Might change later.
+ *
+ */
+function nodeid_sort(g) {
+  var sorted_list = [];
+  for (n in g.nodes)
+    sorted_list.unshift(g.nodes[n]);
+  sorted_list.sort(function(a,b){ return a.id - b.id; })
+    return sorted_list;
+}
+
+/**
+ * Topological Sort
+ *
+ * Sort a directed graph based on incoming edges
+ *
+ * Coded by Jake Stothard
+ */
+function topological_sort(g) {
+  //Mark nodes as "deleted" instead of actually deleting them
+  //That way we don't have to copy g
+
+  for(i in g.nodes)
+    g.nodes[i].deleted = false;
+
+  var ret = topological_sort_helper(g);
+
+  //Cleanup: Remove the deleted property
+  for(i in g.nodes)
+    delete g.nodes[i].deleted
+
+    return ret;
+}
+function topological_sort_helper(g) {
+  //Find node with no incoming edges
+  var node;
+  for(i in g.nodes) {
+    if(g.nodes[i].deleted)
+      continue; //Bad style, meh
+
+    var incoming = false;
+    for(j in g.nodes[i].edges) {
+      if(g.nodes[i].edges[j].target == g.nodes[i]
+          && g.nodes[i].edges[j].source.deleted == false) {
+        incoming = true;
+        break;
+      }
+    }
+    if(!incoming) {
+      node = g.nodes[i];
+      break;
+    }
+  }
+
+  // Either unsortable or done. Either way, GTFO
+  if(node == undefined)
+    return [];
+
+  //"Delete" node from g
+  node.deleted = true;
+
+  var tail = topological_sort_helper(g);
+
+  tail.unshift(node);
+
+  return tail;
+}