Merge remote-tracking branch 'upstream/gh-pages'

index.html

@@ -109,7 +109,9 @@
 <script src="js/ace/ace.js"></script>
 <script src="js/module/tracer.js"></script>
 <script src="js/module/directed_graph.js"></script>
+<script src="js/module/undirected_graph.js"></script>
 <script src="js/module/weighted_directed_graph.js"></script>
+<script src="js/module/weighted_undirected_graph.js"></script>
 <script src="js/module/array2d.js"></script>
 <script src="js/module/array1d.js"></script>
 <script src="js/script.js"></script>

js/module/directed_graph.js

@@ -68,8 +68,7 @@ DirectedGraphTracer.prototype = $.extend(true, Object.create(Tracer.prototype),
         root = root || 0;
         var maxDepth = -1;
 
-        var chk = [];
-        for (var i = 0; i < G.length; i++) chk.push(false);
+        var chk = new Array(G.length);
         var getDepth = function (node, depth) {
             if (chk[node]) throw "the given graph is not a tree because it forms a circuit";
             chk[node] = true;
@@ -233,6 +232,7 @@ DirectedGraphTracer.prototype = $.extend(true, Object.create(Tracer.prototype),
                     color = defaultEdgeColor;
                     break;
             }
+
         return color;
     },
     drawLabel: function (node, context, settings) {
@@ -306,10 +306,10 @@ DirectedGraphTracer.prototype = $.extend(true, Object.create(Tracer.prototype),
     drawOnHover: function (node, context, settings, next) {
         var tracer = this;
 
+        context.setLineDash([5, 5]);
         var nodeIdx = node.id.substring(1);
         graph.edges().forEach(function (edge) {
             var ends = edge.id.substring(1).split("_");
-            context.setLineDash([5, 5]);
             if (ends[0] == nodeIdx) {
                 var color = '#0ff';
                 var source = node;
@@ -331,12 +331,13 @@ var DirectedGraph = {
     random: function (N, ratio) {
         if (!N) N = 5;
         if (!ratio) ratio = .3;
-        var G = [];
+        var G = new Array(N);
         for (var i = 0; i < N; i++) {
-            G.push([]);
+            G[i] = new Array(N);
             for (var j = 0; j < N; j++) {
-                if (i == j) G[i].push(0);
-                else G[i].push((Math.random() * (1 / ratio) | 0) == 0 ? 1 : 0);
+                if (i != j) {
+                    G[i][j] = (Math.random() * (1 / ratio) | 0) == 0 ? 1 : 0;
+                }
             }
         }
         return G;

js/module/undirected_graph.js

+function UndirectedGraphTracer(module) {
+    if (DirectedGraphTracer.call(this, module || UndirectedGraphTracer)) {
+        UndirectedGraphTracer.prototype.init.call(this);
+        return true;
+    }
+    return false;
+}
+
+UndirectedGraphTracer.prototype = $.extend(true, Object.create(DirectedGraphTracer.prototype), {
+    constructor: UndirectedGraphTracer,
+    init: function () {
+        var tracer = this;
+
+        s.settings({
+            defaultEdgeType: 'def'
+        });
+        sigma.canvas.edges.def = function (edge, source, target, context, settings) {
+            var color = tracer.getColor(edge, source, target, settings);
+            tracer.drawEdge(edge, source, target, color, context, settings);
+        };
+    },
+    _setData: function (G) {
+        if (Tracer.prototype._setData.call(this, arguments)) return true;
+
+        graph.clear();
+        var nodes = [];
+        var edges = [];
+        var unitAngle = 2 * Math.PI / G.length;
+        var currentAngle = 0;
+        for (var i = 0; i < G.length; i++) {
+            currentAngle += unitAngle;
+            nodes.push({
+                id: this.n(i),
+                label: '' + i,
+                x: .5 + Math.sin(currentAngle) / 2,
+                y: .5 + Math.cos(currentAngle) / 2,
+                size: 1,
+                color: this.color.default
+            });
+        }
+        for (var i = 0; i < G.length; i++) {
+            for (var j = 0; j <= i; j++) {
+                if (G[i][j] || G[j][i]) {
+                    edges.push({
+                        id: this.e(i, j),
+                        source: this.n(i),
+                        target: this.n(j),
+                        color: this.color.default,
+                        size: 1
+                    });
+                }
+            }
+        }
+
+        graph.read({
+            nodes: nodes,
+            edges: edges
+        });
+        s.camera.goTo({
+            x: 0,
+            y: 0,
+            angle: 0,
+            ratio: 1
+        });
+        this.refresh();
+
+        return false;
+    },
+    e: function (v1, v2) {
+        if (v1 > v2) {
+            var temp = v1;
+            v1 = v2;
+            v2 = temp;
+        }
+        return 'e' + v1 + '_' + v2;
+    },
+    drawOnHover: function (node, context, settings, next) {
+        var tracer = this;
+
+        context.setLineDash([5, 5]);
+        var nodeIdx = node.id.substring(1);
+        graph.edges().forEach(function (edge) {
+            var ends = edge.id.substring(1).split("_");
+            if (ends[0] == nodeIdx) {
+                var color = '#0ff';
+                var source = node;
+                var target = graph.nodes('n' + ends[1]);
+                tracer.drawEdge(edge, source, target, color, context, settings);
+                if (next) next(edge, source, target, color, context, settings);
+            } else if (ends[1] == nodeIdx) {
+                var color = '#0ff';
+                var source = graph.nodes('n' + ends[0]);
+                var target = node;
+                tracer.drawEdge(edge, source, target, color, context, settings);
+                if (next) next(edge, source, target, color, context, settings);
+            }
+        });
+    },
+    drawEdge: function (edge, source, target, color, context, settings) {
+        var prefix = settings('prefix') || '',
+            size = edge[prefix + 'size'] || 1;
+
+        context.strokeStyle = color;
+        context.lineWidth = size;
+        context.beginPath();
+        context.moveTo(
+            source[prefix + 'x'],
+            source[prefix + 'y']
+        );
+        context.lineTo(
+            target[prefix + 'x'],
+            target[prefix + 'y']
+        );
+        context.stroke();
+    }
+});
+
+var UndirectedGraph = {
+    random: function (N, ratio) {
+        if (!N) N = 5;
+        if (!ratio) ratio = .3;
+        var G = new Array(N);
+        for (var i = 0; i < N; i++) G[i] = new Array(N);
+        for (var i = 0; i < N; i++) {
+            for (var j = 0; j < N; j++) {
+                if (i > j) {
+                    G[i][j] = G[j][i] = (Math.random() * (1 / ratio) | 0) == 0 ? 1 : 0;
+                }
+            }
+        }
+        return G;
+    }
+};
\ No newline at end of file

js/module/weighted_directed_graph.js

@@ -215,15 +215,12 @@ var WeightedDirectedGraph = {
         if (!ratio) ratio = .3;
         if (!min) min = 1;
         if (!max) max = 5;
-        var G = [];
+        var G = new Array(N);
         for (var i = 0; i < N; i++) {
-            G.push([]);
+            G[i] = new Array(N);
             for (var j = 0; j < N; j++) {
-                if (i == j) G[i].push(0);
-                else if ((Math.random() * (1 / ratio) | 0) == 0) {
-                    G[i].push((Math.random() * (max - min + 1) | 0) + min);
-                } else {
-                    G[i].push(0);
+                if (i != j && (Math.random() * (1 / ratio) | 0) == 0) {
+                    G[i][j] = (Math.random() * (max - min + 1) | 0) + min;
                 }
             }
         }

js/module/weighted_undirected_graph.js

+function WeightedUndirectedGraphTracer(module) {
+    if (WeightedDirectedGraphTracer.call(this, module || WeightedUndirectedGraphTracer)) {
+        WeightedUndirectedGraphTracer.prototype.init.call(this);
+        return true;
+    }
+    return false;
+}
+
+WeightedUndirectedGraphTracer.prototype = $.extend(true, Object.create(WeightedDirectedGraphTracer.prototype), {
+    constructor: WeightedUndirectedGraphTracer,
+    init: function () {
+        var tracer = this;
+
+        s.settings({
+            defaultEdgeType: 'def'
+        });
+        sigma.canvas.edges.def = function (edge, source, target, context, settings) {
+            var color = tracer.getColor(edge, source, target, settings);
+            tracer.drawEdge(edge, source, target, color, context, settings);
+            tracer.drawEdgeWeight(edge, source, target, color, context, settings);
+        };
+    },
+    _setData: function (G) {
+        if (Tracer.prototype._setData.call(this, arguments)) return true;
+
+        graph.clear();
+        var nodes = [];
+        var edges = [];
+        var unitAngle = 2 * Math.PI / G.length;
+        var currentAngle = 0;
+        for (var i = 0; i < G.length; i++) {
+            currentAngle += unitAngle;
+            nodes.push({
+                id: this.n(i),
+                label: '' + i,
+                x: .5 + Math.sin(currentAngle) / 2,
+                y: .5 + Math.cos(currentAngle) / 2,
+                size: 1,
+                color: this.color.default,
+                weight: 0
+            });
+        }
+        for (var i = 0; i < G.length; i++) {
+            for (var j = 0; j <= i; j++) {
+                if (G[i][j] || G[j][i]) {
+                    edges.push({
+                        id: this.e(i, j),
+                        source: this.n(i),
+                        target: this.n(j),
+                        color: this.color.default,
+                        size: 1,
+                        weight: G[i][j]
+                    });
+                }
+            }
+        }
+
+        graph.read({
+            nodes: nodes,
+            edges: edges
+        });
+        s.camera.goTo({
+            x: 0,
+            y: 0,
+            angle: 0,
+            ratio: 1
+        });
+        this.refresh();
+
+        return false;
+    },
+    e: UndirectedGraphTracer.prototype.e,
+    drawOnHover: UndirectedGraphTracer.prototype.drawOnHover,
+    drawEdge: UndirectedGraphTracer.prototype.drawEdge,
+    drawEdgeWeight: function (edge, source, target, color, context, settings) {
+        var prefix = settings('prefix') || '';
+        if (source[prefix + 'x'] > target[prefix + 'x']) {
+            var temp = source;
+            source = target;
+            target = temp;
+        }
+        console.log(source);
+        console.log(target);
+        WeightedDirectedGraphTracer.prototype.drawEdgeWeight.call(this, edge, source, target, color, context, settings);
+    }
+});
+
+var WeightedUndirectedGraph = {
+    random: function (N, ratio, min, max) {
+        if (!N) N = 5;
+        if (!ratio) ratio = .3;
+        if (!min) min = 1;
+        if (!max) max = 5;
+        var G = new Array(N);
+        for (var i = 0; i < N; i++) G[i] = new Array(N);
+        for (var i = 0; i < N; i++) {
+            for (var j = 0; j < N; j++) {
+                if (i > j && (Math.random() * (1 / ratio) | 0) == 0) {
+                    G[i][j] = G[j][i] = (Math.random() * (max - min + 1) | 0) + min;
+                }
+            }
+        }
+        return G;
+    }
+};
\ No newline at end of file