Clustering by edge weights?

I have a set of names and weighted links in a table (Jplag copying results!) and want to make a graph.
I want to make a graph where those with the highest values (most likely) are closest, and those with lower values are more distant.
I.e. the edge lengths are in proportion to these weights.
i made it something like this:

graph G { 
     /* Nodes: only needed because we need to repeat names */
	a [label = "a"];	
	b [label = "b"];	
	c [label = "c"];	
   /* the graph (edges) */

      a-- b  [weight=1.00, label=89.1]	
      c-- a[weight=0.92, label=81.6]	
      c-- b[weight=0.9, label=80.4]

The label is the actual weightings, and I normalized them all to be one or less for the weights.
but it doesn’t give that result. Edge lengths are not ordered/scaled by the ratios.
And the layouts are also not clustered by any sort of “elastic link” sort of layout.
Am I doing this right, and is this something it can do?

[I only “kind of” (maybe) understand what you want the graph to look like, so …]
You didn’t say which layout engine you are using. If you are using dot, try neato or fdp instead. For fun, you might also try circo & twopi. (Dot is best for directed/structured graphs.)

Thank you, I did try all of them - the online visual editor makes it easy!

I anted the graph to look like clusters of people who had highest copying metric are clustered, basically the graph to show tight loosely coupled nodes according to that measure.

dot is readable but layout doesn’t seem to use the weights for edge length rankings. Neato is a mess. Circo is interesting, but similarly not using

Maybe try neato, experimenting with model, mode, and overlap attributes.

Thanks. Neato made a mess of it!

I am not very familiar with the tool, and thus haven’t learned or played with these attributes you mention.
I was hoping for a tool where I could do some manual rearrangements to help out!

Dot was better, and some edges do appear in order of weights, others not - perhaps that is the best it could while trying for the general correct idea?

The “problem” with dot is that it lays out nodes in ranks (rows). This is why edge lengths are not really based on weight. I believe that dot is a bad choice for your graph.
It would help if you would share your source.
Here is an anonymizer program that will change the node names & labels. (I did not write it, it is part of Graphviz source).
save it as anon.gvpr, and use it like so:
gvpr -f anon.gvpr >
gvpr is part of the Graphviz toolset and is documented here:

/* anonymize the graph */
  node_t map[node_t];
  graph_t dup;
  int id = 0;
  char* gtype;
  node_t n;
  edge_t e;
  char* l;

  if ($.directed) gtype = "D";
  else gtype = "U";
  if ($.strict) gtype = gtype + "S";
  dup = graph ($.name, gtype);
  $tvtype = TV_ne;
N {
  n = node(dup, (char*)id);
  map[$] = n; 
E {
  edge (map[$.tail],map[$.head],"");
  write (dup);

the data:
The edge weights are the original rankings, they were then normalized by (/max) to scale to 1.0 and less.

/* dependency graph */

JPlag copying graph

Command to produce the output: “neato -Tpng thisfile > thisfile.png”

graph G {
/* Nodes: only needed because we need to repeat names */
n1 [label = “n1”];
n2 [label = “n2”];
n3 [label = “n3”];
n4 [label = “n4”];
n5 [label = “n5”];
n6 [label = “n6”];
n7 [label = “n7”];
n8 [label = “n8”];
n9 [label = “n9”];
n10 [label = “n10”];
n11 [label = “n11”];

/* the graph (edges) */

  n1      -- n3     [weight=1.00, label=89.1]	
  n10     -- n1     [weight=0.92, label=81.6]	
  n10     -- n3     [weight=0.9, label=80.4]	
  n9      -- n4     [weight=0.89, label=79.2]	
  n6      -- n4     [weight=0.87, label=77.9]	
  n9      -- n6     [weight=0.86, label=76.5]	
  n9      -- n8     [weight=0.74, label=65.5]	
  n11     -- n10    [weight=0.73, label=65.3]	
  n7      -- n2     [weight=0.73, label=64.9]	
  n7      -- n4     [weight=0.7, label=62.4]	
  n9      -- n7     [weight=0.7, label=62.3]	
  n11     -- n3     [weight=0.68, label=60.9]	
  n8      -- n4     [weight=0.67, label=59.3]	
  n9      -- n2     [weight=0.67, label=59.3]	
  n11     -- n1     [weight=0.66, label=58.9]	
  n7      -- n6     [weight=0.65, label=58.2]	
  n8      -- n6     [weight=0.65, label=58]	
  n2      -- n4     [weight=0.64, label=56.9]	
  n2      -- n6     [weight=0.6, label=53.9]	
  n8      -- n7     [weight=0.55, label=48.8]	
  n6      -- n5     [weight=0.52, label=46.3]	
  n8      -- n2     [weight=0.51, label=45.7]	
  n7      -- n10    [weight=0.51, label=45.4]	
  n9      -- n5     [weight=0.49, label=43.3]	
  n11     -- n7     [weight=0.49, label=43.3]	
  n4      -- n5     [weight=0.48, label=42.7]	
  n7      -- n3     [weight=0.48, label=42.5]	
  n8      -- n5     [weight=0.46, label=41.2]	
  n2      -- n5     [weight=0.46, label=41]	
  n7      -- n5     [weight=0.46, label=40.8]	


I wonder about your comment - " dot is a bad choice for your graph…"
are you saying not to try to use graphviz?
I thought that .dot files were it’s standard (only?) input format type.
Please excuse novice naivete!

dot is just one of 8 layout engines. Three engines are very specialized, so that leaves 5: dot, neato, fdp, circo, and twopi. All take the same input (with a handful of exceptions), but produce very different results.
I think the dot, twopi, and circo layout engines are not well suited to you goal (famous last words).
Here is a “better” result (more info later, I broke my testing script):

Thank you; it’s helping me learn more about this!