It is actually feasible to do *inline* calculations of the radius and enforce the text width to do this.

The method needed is the `TikZ`

`let`

commands (which is enabled by the library `calc`

).

It basically allows you to do arithmetic on coordinates in the path:

An example from the manual is this:

```
\coordinate (a) at (rnd,rnd);
\coordinate (b) at (3-rnd,3-rnd);
\draw (a) -- (b);
\node (c) at (1,2) {x};
\draw let \p1 = ($ (a)!(c)!(b) - (c) $),
\n1 = {veclen(\x1,\y1)}
in circle [at=(c), radius=\n1];
```

As coordinates `a`

and `b`

are located at random, it was impossible to align the size of the circle draw, without using arithmetic to solve the problem of drawing a circle which just touches the line between `a`

and `b`

.

What `let`

basically does is allow to access `x`

and `y`

coordinates of specific points and do operations on them. And together with the `calc`

library you have, virtually, endless possibilities to align, calculate lengths etc.

In your case, you need to calculate the length of the vector between them, minus the radius of the nodes.

```
\path[->]
let \p1 = ($(Rd)-(Bl)$), % Save length between centers of the nodes
\p2 = ($(Rd)-(Rd.south)+(Bl)-(Bl.south)$), % Calculate the radius
\n1 = {veclen(\x1,\y1)-veclen(\x2,\y2)} in % The allowed text width
(Rd) edge node[sloped,anchor=center,align=center,above,text width=\n1]
{Given a timeslice} (Rn) ...
```

This will automatically adjust to the length between the two nodes.

An example at different `node distance`

is this:

```
\foreach \myx in {2.5cm,3cm,4cm,5cm} {
\begin{tikzpicture}[shorten >=2pt,node distance=\myx,on grid,auto]
\node[state] (Rd) {Ready};
\node[state] (Rn) [above right =of Rd] {Run};
\path[->]
let \p1 = ($(Rd)-(Rn)$),
\p2 = ($(Rd)-(Rd.south)+(Rn)-(Rn.south)$),
\n1 = {veclen(\x1,\y1)-veclen(\x2,\y2)} in
(Rd) edge node[sloped,anchor=center,align=center,above,text width=\n1]
{Given a timeslice} (Rn);
\end{tikzpicture}
}
```

Which produces the following figure:

In your case, you can even create a new command:

```
\def\mylet#1#2{%
let \p1 = ($(#1)-(#2)$),%
\p2 = ($(#1)-(#1.south)+(#2)-(#2.south)$), %
\n1 = {veclen(\x1,\y1)-veclen(\x2,\y2)} in %
}
```

However, this limits you to recreate the `\path`

command on each connection made (notice that you need the `align=center`

for alignment on the path correctly, this is because when the text is too small the text width is too large), try and play with node distance and see the results.

```
\begin{tikzpicture}[shorten >=2pt,node distance=4cm,on grid,auto
,every node/.append style={align=center}]
\node[state] (Rd) {Ready};
\node[state] (Rn) [above right =of Rd] {Run};
\node[state] (Bl) [below right =of Rd] {Blocked};
\node[state] (Nr) [below right =of Rn] {Dead};
\path[->] \mylet{Rd}{Rn} (Rd)
edge node[sloped,anchor=center,above,text width=\n1]
{Given a timeslice} (Rn);
\path[->] \mylet{Rd}{Bl}
(Rd) edge node[sloped,anchor=center,below,text width=\n1]
{Asks for I/O} (Bl);
\path[->] \mylet{Rd}{Nr}
(Rd) edge node[text width=\n1]
{Gets killed by kernel} (Nr);
\path[->] (Bl) edge node {Out of memory} (Nr);
\end{tikzpicture}
```

# Exemplified

So how does the `let`

command work for `TikZ`

?

Consider the following:

```
\coordinate (a) at (1,0);
\draw (a) -- ++(2,0);
```

This will create a coordinate called `a`

and then draw from `a`

to plus two units in the *x*-direction.

The **exact** same drawing can be realized like this:

```
\coordinate (a) at (1,0);
\draw[thick,dashed] let \p1 = (a) in (\p1) -- ++(2,0);
```

For now this is obviously not the best way (the former is much clearer and shorter). However, this allows to do arithmetic on `x`

and `y`

coordinates for specific coordinates (in this case the point `a`

or `(1,0)`

can be used in calculations of subsequent points.

The best example is probably to step through the solution supplied to you:

```
let \p1 = ($(Rd)-(Bl)$)
```

As in the previous example we let `\p1`

become a coordinate which is calculated within the outermost parenthesis. Within those we encounter the form:

```
$(Rd)-(Bl)$
```

this is a typical `TikZ`

command to substract the coordinate `Rd`

from `Bl`

. In this case these coordinates refers to nodes, and in such cases they correspond to the center-point of the node, i.e. the center of the circle. So if `Rd`

and `Bl`

where defined as this:

```
\node (Rd) at (1,1) {Rd};
\node (Bl) at (4,4) {Bl};
```

now we can calculate the vector pointing from `Bl`

to `Rd`

by subtracting `Bl`

from `Rd`

:

```
\draw (0,0) -- ($(Rd)-(Bl)$); % Will draw (0,0) -- (-3,-3)
```

So in the example I gave you, we would have `\p1 = (-3,-3)`

. The following command `\p2 = ($(Rd)-(Rd.south)+(Bl)-(Bl.south)$)`

takes the points show in the following picture and calculates, simultaneously, the `r_1`

and `r_2`

vectors and adding them.

Now we have the vector going from the middle of one node, to the middle of the other node *AND* we have the vector that has a length of both nodes radius's.

Now we can calculate the length between the two nodes by: subtracting the radius vector from the node center vectors.

```
\n1 = {veclen(\x1,\y1)-veclen(\x2,\y2)}
```

If it makes more sense, you could also have done:

```
...
let \p1 = ($(Rd)-(Rn)$), % Vector between centers
\p2 = ($(Rd)-(Rd.south)$), % Vector with length of `Rd` radius
\p3 = ($(Rn)-(Rn.south)$), % Vector with length of `Rn` radius
% (length between centers) - (radius of `Rd`) - (radius of `Rn`)
\n1 = {veclen(\x1,\y1)-veclen(\x2,\y2)-veclen(\x3,\y3)}
in ...
```

## Best Answer

An equation-oriented environment such as

`align*`

isn't well suited for the task at hand. Instead, consider using a table-like environment such as`tabularx`

.The following code uses the construct

`@{${}={}$}`

to insert a properly-spaced`=`

symbol between the first and second column of the`tabularx`

environment; the`X`

column type, used for the second column, "wraps" its contents automatically as needed. The overall width of the table is set to`0.75\textwidth`

-- adjust this setting as you see fit.