I am preparing a Neo4j database on which I would like to do some network 
analysis. It is a representation of a weakly connected and static physical 
system, and will have in the region of 50 million nodes where, lets say, 
about 50 nodes will connect to a parent node, which in turn is linked 
(think streets and intersections) to a network of other parent nodes.

For most of the analysis, I will be using a weighted distance decay, so 
analysis of things like "betweenness" or "centrality" will be computed for 
the parent node network, but only to a limited extent. So, for example, if 
(a)--(b)--(c)--(d)--(e), then the computation will only be based up to, 
say, two steps away. So (a) will consider (b) and (c), whereas (c) will 
consider two steps in either direction.

My question is a conceptual and strategic one: What is the best approach 
for doing this kind of analysis with neo4j?

I currently work with Python, but it appears that for speed, flexibility, 
and use of complex graph algorithms, I am better off working with the 
embedded Java API for direct and powerful access to the graph? Or is an 
approach using something like bulb flow with gremlin also feasible? How 
does the power and flexibility of the different embedded tools compare - 
e.g. Python embedded vs. Java vs. Node.js?

Thanks.

-- 
You received this message because you are subscribed to the Google Groups 
"Neo4j" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to neo4j+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to