mirror of https://gitee.com/bigwinds/arangodb
364 lines
9.2 KiB
JavaScript
364 lines
9.2 KiB
JavaScript
/*jslint indent: 2, nomen: true, maxlen: 100, white: true plusplus: true */
|
|
/*global $, d3, _, console, alert*/
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Graph functionality
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2010-2012 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Michael Hackstein
|
|
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function NodeReducer(nodes, edges) {
|
|
"use strict";
|
|
|
|
if (nodes === undefined) {
|
|
throw "Nodes have to be given.";
|
|
}
|
|
if (edges === undefined) {
|
|
throw "Edges have to be given.";
|
|
}
|
|
|
|
var self = this,
|
|
getDegree = function(id) {
|
|
return $.grep(nodes, function(e){
|
|
return e._id === id;
|
|
})[0];
|
|
},
|
|
|
|
// Will Overwrite dQ, a and heap!
|
|
populateValues = function(dQ, a, heap) {
|
|
var m = edges.length,
|
|
twoM = 2 * m,
|
|
cFact = 1 / twoM;
|
|
_.each(nodes, function(n) {
|
|
a[n._id] = (n._outboundCounter + n._inboundCounter) / twoM;
|
|
});
|
|
|
|
_.each(edges, function(e) {
|
|
var sID, lID;
|
|
if (e.source._id < e.target._id) {
|
|
sID = e.source._id;
|
|
lID = e.target._id;
|
|
} else {
|
|
sID = e.target._id;
|
|
lID = e.source._id;
|
|
}
|
|
if (dQ[sID] === undefined) {
|
|
dQ[sID] = {};
|
|
heap[sID] = {};
|
|
heap[sID].val = -1;
|
|
}
|
|
dQ[sID][lID] = cFact - a[sID] * a[lID];
|
|
if (heap[sID].val < dQ[sID][lID]) {
|
|
heap[sID].val = dQ[sID][lID];
|
|
heap[sID].sID = sID;
|
|
heap[sID].lID = lID;
|
|
}
|
|
});
|
|
},
|
|
|
|
getLargestOnHeap = function(heap) {
|
|
return _.max(heap, function(e) {
|
|
return e.val;
|
|
});
|
|
},
|
|
|
|
joinCommunities = function(sID, lID, coms, heap, val) {
|
|
coms[sID] = coms[sID] || {com: [sID], q: 0};
|
|
coms[lID] = coms[lID] || {com: [lID], q: 0};
|
|
var old = coms[sID].com,
|
|
newC = coms[lID].com;
|
|
coms[lID].com = old.concat(newC);
|
|
coms[lID].q += coms[sID].q + val;
|
|
delete coms[sID];
|
|
},
|
|
|
|
|
|
getDQValue = function(dQ, a, b) {
|
|
if (a < b) {
|
|
if (dQ[a] !== undefined) {
|
|
return dQ[a][b];
|
|
}
|
|
return undefined;
|
|
}
|
|
if (dQ[b] !== undefined) {
|
|
return dQ[b][a];
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
setDQValue = function(dQ, heap, a, b, val) {
|
|
if (a < b) {
|
|
if(dQ[a] === undefined) {
|
|
dQ[a] = {};
|
|
heap[a] = {};
|
|
heap[a].val = -1;
|
|
}
|
|
dQ[a][b] = val;
|
|
if (heap[a].val < val) {
|
|
heap[a].val = val;
|
|
heap[a].sID = a;
|
|
heap[a].lID = b;
|
|
}
|
|
} else {
|
|
if(dQ[b] === undefined) {
|
|
dQ[b] = {};
|
|
heap[b] = {};
|
|
heap[b].val = -1;
|
|
}
|
|
dQ[b][a] = val;
|
|
if (heap[b].val < val) {
|
|
heap[b].val = val;
|
|
heap[b].sID = b;
|
|
heap[b].lID = a;
|
|
}
|
|
}
|
|
},
|
|
|
|
delDQValue = function(dQ, a, b) {
|
|
if (a < b) {
|
|
delete dQ[a][b];
|
|
} else {
|
|
delete dQ[b][a];
|
|
}
|
|
},
|
|
|
|
updateValues = function(largest, dQ, a, heap) {
|
|
var lID = largest.lID,
|
|
sID = largest.sID;
|
|
_.each(nodes, function (n) {
|
|
var id = n._id,
|
|
c1, c2;
|
|
if (id === sID || id === lID) {
|
|
return null;
|
|
}
|
|
c1 = getDQValue(dQ, id, sID);
|
|
c2 = getDQValue(dQ, id, lID);
|
|
if (c1 !== undefined) {
|
|
if (c2 !== undefined) {
|
|
setDQValue(dQ, heap, id, lID, c1 + c2);
|
|
} else {
|
|
setDQValue(dQ, heap, id, lID, c1 - 2 * a[lID] * a[id]);
|
|
}
|
|
delDQValue(dQ, id, sID);
|
|
} else {
|
|
if (c2 !== undefined) {
|
|
setDQValue(dQ, heap, id, lID, c2- 2 * a[sID] * a[id]);
|
|
}
|
|
}
|
|
});
|
|
delete dQ[sID];
|
|
delete heap[sID];
|
|
a[lID] += a[sID];
|
|
delete a[sID];
|
|
},
|
|
|
|
sortBySize = function(a, b) {
|
|
return b.length - a.length;
|
|
},
|
|
|
|
neighbors = function(sID) {
|
|
var neigh = [];
|
|
_.each(edges, function(e) {
|
|
if (e.source._id === sID) {
|
|
neigh.push(e.target._id);
|
|
return;
|
|
}
|
|
if (e.target._id === sID) {
|
|
neigh.push(e.source._id);
|
|
return;
|
|
}
|
|
});
|
|
return neigh;
|
|
},
|
|
|
|
minDist = function(dist) {
|
|
return function(a) {
|
|
return dist[a];
|
|
};
|
|
},
|
|
|
|
dijkstra = function(sID) {
|
|
var dist = {},
|
|
toDo, next, neigh,
|
|
filterNotNext = function(e) {
|
|
return e !== next;
|
|
},
|
|
computeNeighbours = function(v) {
|
|
if (_.contains(toDo, v)) {
|
|
if (dist[v] > dist[next] + 1) {
|
|
dist[v] = dist[next] + 1;
|
|
}
|
|
}
|
|
};
|
|
|
|
toDo = _.pluck(nodes, "_id");
|
|
_.each(toDo, function(n) {
|
|
dist[n] = Number.POSITIVE_INFINITY;
|
|
});
|
|
dist[sID] = 0;
|
|
while(toDo.length > 0) {
|
|
next = _.min(toDo, minDist(dist));
|
|
if (next === Number.POSITIVE_INFINITY) {
|
|
break;
|
|
}
|
|
toDo = toDo.filter(filterNotNext);
|
|
neigh = neighbors(next);
|
|
_.each(neigh, computeNeighbours);
|
|
}
|
|
return dist;
|
|
},
|
|
|
|
floatDistStep = function(dist, depth, todo) {
|
|
if (todo.length === 0) {
|
|
return true;
|
|
}
|
|
var nextTodo = [];
|
|
_.each(todo, function(t) {
|
|
if (dist[t] !== Number.POSITIVE_INFINITY) {
|
|
return;
|
|
}
|
|
dist[t] = depth;
|
|
nextTodo = nextTodo.concat(neighbors(t));
|
|
});
|
|
return floatDistStep(dist, depth+1, nextTodo);
|
|
},
|
|
|
|
floatDist = function(sID) {
|
|
var dist = {};
|
|
_.each(_.pluck(nodes, "_id"), function(n) {
|
|
dist[n] = Number.POSITIVE_INFINITY;
|
|
});
|
|
dist[sID] = 0;
|
|
if (floatDistStep(dist, 1, neighbors(sID))) {
|
|
return dist;
|
|
}
|
|
throw "FAIL!";
|
|
},
|
|
|
|
communityDetectionStep = function(dQ, a, heap, coms) {
|
|
//console.log("COMS: " + JSON.stringify(coms));
|
|
//console.log("HEAP: " + JSON.stringify(heap));
|
|
var l = getLargestOnHeap(heap);
|
|
if (l === Number.NEGATIVE_INFINITY || l.val < 0) {
|
|
return false;
|
|
}
|
|
joinCommunities(l.sID, l.lID, coms, heap, l.val);
|
|
updateValues(l, dQ, a, heap);
|
|
return true;
|
|
},
|
|
|
|
addNode = function(bucket, node) {
|
|
bucket.push(node);
|
|
|
|
},
|
|
|
|
getSimilarityValue = function(bucket, node) {
|
|
if (bucket.length === 0) {
|
|
return 1;
|
|
}
|
|
var comp = bucket[0],
|
|
props = _.union(_.keys(comp), _.keys(node)),
|
|
countMatch = 0,
|
|
propCount = 0;
|
|
_.each(props, function(key) {
|
|
if (comp[key] !== undefined && node[key]!== undefined) {
|
|
countMatch++;
|
|
if (comp[key] === node[key]) {
|
|
countMatch += 4;
|
|
}
|
|
}
|
|
});
|
|
propCount = props.length * 5;
|
|
propCount++;
|
|
countMatch++;
|
|
return countMatch / propCount;
|
|
};
|
|
|
|
self.getCommunity = function(limit, focus) {
|
|
var dQ = {},
|
|
a = {},
|
|
heap = {},
|
|
coms = {},
|
|
res = [],
|
|
dist = {},
|
|
dist2 = {},
|
|
detectSteps = true,
|
|
sortByDistance = function (a, b) {
|
|
var d1 = dist[_.min(a,minDist(dist))],
|
|
d2 = dist[_.min(b,minDist(dist))],
|
|
val = d2 - d1;
|
|
if (val === 0) {
|
|
val = coms[b[b.length-1]].q - coms[a[a.length-1]].q;
|
|
}
|
|
return val;
|
|
};
|
|
if (nodes.length === 0 || edges.length === 0) {
|
|
throw "Load some nodes first.";
|
|
}
|
|
populateValues(dQ, a, heap);
|
|
while (detectSteps) {
|
|
detectSteps = communityDetectionStep(dQ, a, heap, coms);
|
|
}
|
|
res = _.pluck(_.values(coms), "com");
|
|
if (focus !== undefined) {
|
|
dist = floatDist(focus._id);
|
|
res = res.filter(function(e) {return !_.contains(e, focus._id);});
|
|
res = res.filter(function(e) {return e.length > 1;});
|
|
res.sort(sortByDistance);
|
|
} else {
|
|
res = res.filter(function(e) {return e.length > 1;});
|
|
}
|
|
return res[0];
|
|
};
|
|
|
|
self.bucketNodes = function(toSort, numBuckets) {
|
|
var res = [],
|
|
threshold = 0.5;
|
|
if (toSort.length <= numBuckets) {
|
|
res = _.map(toSort, function(n) {
|
|
return [n];
|
|
});
|
|
return res;
|
|
}
|
|
_.each(toSort, function(n) {
|
|
var i, shortest, sLength;
|
|
shortest = 0;
|
|
sLength = Number.POSITIVE_INFINITY;
|
|
for (i = 0; i < numBuckets; i++) {
|
|
res[i] = res[i] || [];
|
|
if (getSimilarityValue(res[i], n) > threshold) {
|
|
addNode(res[i], n);
|
|
return;
|
|
}
|
|
if (sLength > res[i].length) {
|
|
shortest = i;
|
|
sLength = res[i].length;
|
|
}
|
|
}
|
|
addNode(res[shortest], n);
|
|
});
|
|
return res;
|
|
};
|
|
|
|
}
|