I just want to create a basic ruler with numbers next to the dashes
Am I using dot wrong or what is the matter?
What would be a better approach?
rendered
digraph timeline {
node [fixedsize=true height=.01 label="" shape=box width=.1 xlp="100,0"]
edge [arrowhead=none arrowtail=none]
1 -> 2 [xlabel=1]
2 -> 3 [xlabel=2]
3 -> 4 [xlabel=3]
4 -> 5 [xlabel=4]
5 -> 6 [xlabel=5]
6 -> 7 [xlabel=6]
7 -> 8 [xlabel=7]
8 -> 9 [xlabel=8]
9 -> 10 [xlabel=9]
}
dot is not well suited for this - I'd try gpic. But is this close enough?
digraph timeline {
size="2,12!"
ratio=fill
node [fixedsize=true height=.01 label="" shape=box width=.1 xlp="100,0"]
edge [arrowhead=none arrowtail=none]
0 [label=""]
1 [label="1"]
2 [label="2 "]
3 [label="3 "]
4 [label="4 "]
5 [label="5 "]
6 [label="6 "]
7 [label="7 "]
8 [label="8 "]
9 [label="9 "]
0->1->2->3->4->5->6->7->8->9
}
Related
I am trying to design an algorithm to calculate how volatile the price fluctuations of a commodity are.
The way I would like this to work is that if the price of a commodity constantly goes up and down, it should have a higher score than if the price of the commodity gradually increases and then falls in price rapidly.
Here is an example of what I mean:
Commodity A: 1 -> 2 -> 3 -> 2 -> 1 -> 3 -> 4 -> 2 -> 1
Commodity B: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 2
Commodity C: 1 -> 2 -> 3 -> 4 -> 5 -> 4 -> 3 -> 2-> 1
Commodity A has a 'wave' like pattern in that its price goes up and falls down on a regular basis.
Commodity B has a 'cliff' like pattern in that the price goes up gradually and then falls steeply.
Commodity C has a 'hill' like pattern in that the price rises gradually and then falls gradually.
A should receive the highest ranking, followed by C, followed by B. The more of a wave pattern the price of the commodity follows, the higher a ranking it should have.
Does have any suggestions for an algorithm that could do this?
Thanks!
My Approach looks something like this.
For my algorithm, I am considering the above example.
A: 1 -> 2 -> 3 -> 2 -> 1 -> 3 -> 4 -> 2 -> 1
B: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 2
C: 1 -> 2 -> 3 -> 4 -> 5 -> 4 -> 3 -> 2-> 1
Now I will squash these list, by squash i mean taking the start value and end value of an increasing or decreasing sequence.
So, after squashing the list will look something like this.
A: 1 -> 3 -> 1 -> 4 -> 1
B: 1 -> 8 -> 2
C: 1 -> 5 -> 1
Now once this it done, I take the difference between i and i+1 element and then take the average and based on the average, I give them the rank.
So the difference between i and i+1 element will look something like this
2 2 3 3
A: 1 --> 3 --> 1 --> 4 --> 1
7 6
B: 1 --> 8 --> 2
4 4
C: 1 --> 5 --> 1
Now let's sum this difference and take the average.
A: (2+2+3+3)/4 = 2.5
B: (7+6)/2 = 6.5
C: (4+4)/2 = 4
Now we can assign ranks based on this average value where
A < C < B
Hope this helps!
I'm using graphviz (dot) to generate time expanded graph to use in my master thesis. However, my drawing results the following graph:
As you can see, the third line is a little bit shifted to the right.I want all the lines in the same horizontal line. Also i want the x.th node in each line to stay at the same horizontal line of other x.th nodes of lines. Changing the edge weights would not helped me.
I could not find anything related to this problem so far.
What i want to achieve is something like this:
Here is my code:
digraph G {
1[label="1"]
2[label="1"]
3[label="1"]
4[label="1"]
5[label="1"]
6[label="1"]
7[label="2"]
8[label="2"]
9[label="2"]
10[label="2"]
11[label="2"]
12[label="2"]
13[label="3"]
14[label="3"]
15[label="3"]
16[label="3"]
17[label="3"]
18[label="3"]
19[label="4"]
20[label="4"]
21[label="4"]
22[label="4"]
23[label="4"]
24[label="4"]
rankdir="LR";
node[width=0.15, height=0.15, shape=point];
edge[weight=500, label="1"];
1 -> 2 -> 3 -> 4 -> 5 -> 6 ;
7 -> 8 -> 9 -> 10 -> 11 -> 12 ;
13 -> 14 -> 15 -> 16 -> 17 -> 18 ;
19 -> 20 -> 21 -> 22 -> 23 -> 24 ;
edge[weight=3];
1 -> 9;
2 -> 9;
3 -> 11;
13 -> 22;
14 -> 22;
15 -> 24;
edge[weight=1];
1 -> 14;
2 -> 15;
3 -> 17;
7 -> 21;
8 -> 23;
9 -> 22;
}
Any help would be appreciated.
Instead of using weight try using the attribute constraint=false for all edges which go from one "line" to another.
Setting constraint to false makes graphviz to not consider those edges when laying out the nodes of the graph.
See also this very similar question & answer
As far as I know, the only way is to specify an explicit position for each individual node.
See: How to force node position (x and y) in graphviz
I have the following dot:
digraph G
{
rank="same";
subgraph sys
{
1 [shape=record, label="| | Système"];
}
subgraph obj
{
2 [shape=box, label="Sites"];
3 [shape=box, label="Sociétés de\nmaintenance"];
1 -> 2 [arrowhead=none] [label="a"];
1 -> 3 [arrowhead=none] [label="b"];
}
subgraph constraints
{
4 [style=dotted, label="Surveiller"];
5 [style=dotted, label="Effectuer des\ninterventions"];
4 -> 2 [style=dotted];
4 -> 3 [style=dotted];
5 -> 2 [style=dotted];
5 -> 3 [style=dotted];
}
}
Which gives me this image:
But I want to have a subgraph by column (1 on the first column, 2-3 on the second and 4-5 on the last).
Is there a way to do that?
For your help,
Thanks by advance.
digraph G
{
rank=same
rankdir=LR
subgraph sys
{
1 [shape=record, label="| | Système"]
}
subgraph obj
{
node [shape=box]
2 [label="Sites"]
3 [label="Sociétés de\nmaintenance"]
}
subgraph constraints
{
node [style=dotted]
4 [label="Surveiller"]
5 [label="Effectuer des\ninterventions"]
}
edge [style=invis, weight=2]
2->4
3->5
edge [style=dotted]
4 -> 2
4 -> 3
5 -> 2
5 -> 3
edge [style="" arrowhead=none]
1 -> 2 [label="a"]
1 -> 3 [label="b"]
}
This solution is the same as suggested by #alexandr_anturis (+1), but I have removed some irrelevant 'syntax noise', because I feel that such a complex and powerful specification as dot language benefits of any simplification available.
Use rankdir and hidden edges with appropriate weight.
Picture of the result:
digraph G
{
rank="same";
layout="dot";
rankdir=LR;
subgraph sys
{
style=filled;
1 [rank=1, shape=record, label="| | Système"];
}
subgraph obj
{
2 [rank=2,shape=box, label="Sites"];
3 [rank=3,shape=box, label="Sociétés de\nmaintenance"];
}
subgraph constraints
{
4 [rank=4,style=dotted, label="Surveiller"];
5 [rank=5,style=dotted, label="Effectuer des\ninterventions"];
}
2->3->4->5 [color=white, weight=100];
rankdir=LR;
4 ->2 [style=dotted, w=0];
4 -> 3 [style=dotted, w=0];
5 -> 2 [style=dotted, w=0];
5 -> 3 [style=dotted, w=0];
1 -> 2 [arrowhead=none] [label="a"];
1 -> 3 [arrowhead=none] [label="b"];
}
You can use something like this. The way to make what you want is to use rankdir and add invisible edges for correct ranking.
I have an array which stores the relations of values, which makes several trees something like:
So, in this case, my array would be (root, linked to)
(8,3)
(8,10)
(3,1)
(3,6)
(6,4)
(6,7)
(10,14)
(14,13)
And i'd like to set all the root values in the array to the main root in the tree (in all trees):
(8,3)
(8,1)
(8,6)
(8,4)
(8,7)
(8,10)
(8,14)
(8,13)
What algorithm should i investigate?
1) Make a list of all the unique first elements of the tuples.
2) Remove any that also appear as the second element of a tuple.
3) You'll be left with the root (8 here). Replace the first elements of all tuples with this value.
EDIT:
A more complicated approach that will work with multiple trees would be as follows.
First, convert to a parent lookup table:
1 -> 3
3 -> 8
4 -> 6
6 -> 3
7 -> 6
10 -> 8
13 -> 14
14 -> 10
Next, run "find parent with path compression" on each element:
1)
1 -> 3 -> 8
gives
1 -> 8
3 -> 8
4 -> 6
...
3)
3 -> 8
4)
4 -> 6 -> 3 -> 8
gives
1 -> 8
3 -> 8
4 -> 8
6 -> 8
7 -> 6
...
6)
6 -> 8 (already done)
7)
7 -> 6 -> 8
etc.
Result:
1 -> 8
3 -> 8
4 -> 8
6 -> 8
7 -> 8
...
Then convert this back to the tuple list:
(8,1)(8,3)(8,4)...
The find parent with path compression algorithm is as find_set would be for disjoint set forests, e.g.
int find_set(int x) const
{
Element& element = get_element(x);
int& parent = element.m_parent;
if(parent != x)
{
parent = find_set(parent);
}
return parent;
}
The key point is that path compression helps you avoid a lot of work. In the above, for example, when you do the lookup for 4, you store 6 -> 8, which makes later lookups referencing 6 faster.
So assume you have a list of tuples representing the points:
def find_root(ls):
child, parent, root = [], [], []
for node in ls:
parent.append(node[0])
child.append(node[1])
for dis in parent:
if (!child.count(dis)):
root.append(dis)
if len(root) > 1 : return -1 # failure, the tree is not formed well
for nodeIndex in xrange(len(ls)):
ls[nodeIndex] = (root[0], ls[nodeIndex][1])
return ls
I'm attempting to diagram an extensive form game in GraphViz. Compiling the code results in a graph that is correct in all ways except one. I want the "War" label to be placed to the left of the edge it labels, such that the edge is closest to "r" and not "W".
This is my "game" or graph so far:
digraph hierarchy_of_D {
graph [rankdir ="UD"]
node [color=black,shape=circle]
//splines="polyline"
I [label="R"]
subgraph infoset1
{
label="whatever"
rank="same"
1 [label="C"]
2 [label="C"]
}
I -> 1 [label="War"] //fix how this floats right of the line
I -> 2 [label="Peace"]
1 -> 2 [style=dashed, dir=none]
subgraph info21
{
rank="same"
3 [label="(2,2)", rank=sink, shape="plaintext"]
4 [label="(5,1)", rank=sink, shape="plaintext"]
5 [label="(1,5)", rank=sink, shape="plaintext"]
6 [label="(4,4)", rank=sink, shape="plaintext"]
}
1 -> 3 [label="War"]
1 -> 4 [label="Peace"]
2 -> 5 [label="War"]
2 -> 6 [label="Peace"]
}
Any ideas? I've already tried the following, which does not do what I want:
1 -> 3 [label="War/l"]
See also this question and that question, neither of which have an answer. C'mon now, this is worth triple points!
Triple points? Well then, the correct answer is that you cannot choose the placement of edge labels.
However, you may play with headlabel, labeldirection and labelangle:
digraph hierarchy_of_D {
node [color=black,shape=circle]
I [label="R"]
subgraph infoset1
{
label="whatever"
rank="same"
1 [label="C"]
2 [label="C"]
}
I -> 1 [headlabel="War", labeldistance=3, labelangle=40]
I -> 2 [headlabel="Peace", labeldistance=3, labelangle=-40]
1 -> 2 [style=dashed, dir=none]
subgraph info21
{
rank="same"
3 [label="(2,2)", rank=sink, shape="plaintext"]
4 [label="(5,1)", rank=sink, shape="plaintext"]
5 [label="(1,5)", rank=sink, shape="plaintext"]
6 [label="(4,4)", rank=sink, shape="plaintext"]
}
1 -> 3 [headlabel="War", labeldistance=3, labelangle=40]
1 -> 4 [headlabel="Peace", labeldistance=3, labelangle=-40]
2 -> 5 [headlabel="War", labeldistance=3, labelangle=40]
2 -> 6 [headlabel="Peace", labeldistance=3, labelangle=-40]
}
Output:
Just for fun, an other workaround I just found:
By forcing straight edges between nodes using splines=false and defining edges twice, the edges are drawn as if they were one single edge, but the labels of each edge get to are drawn (most of the time) on different sides of the edge.
Therefore by having one edge without a label, and the other one with a label, it is possible to influence the placement of the edge(s) label(s).
Your example:
digraph hierarchy_of_D {
splines=false;
node [color=black,shape=circle]
I [label="R"]
subgraph infoset1
{
rank="same"
1 [label="C"]
2 [label="C"]
}
I -> 1 [label="War "]
I -> 1 [label=" "]
I -> 2 [label=""]
I -> 2 [label="Peace"]
1 -> 2 [style=dashed, dir=none]
subgraph info21
{
rank="same"
3 [label="(2,2)", rank=sink, shape="plaintext"]
4 [label="(5,1)", rank=sink, shape="plaintext"]
5 [label="(1,5)", rank=sink, shape="plaintext"]
6 [label="(4,4)", rank=sink, shape="plaintext"]
}
1 -> 3 [label="War"]
1 -> 3 [label=""]
1 -> 4 [label=""]
1 -> 4 [label="Peace"]
2 -> 5 [label=""]
2 -> 5 [label="War "]
2 -> 6 [label=""]
2 -> 6 [label="Peace"]}
And the output:
It's not perfect, and your mileage may vary depending on the graph, but I thought it was worth mentioning it.