The evolute of a curve

Page by Murray Bourne, IntMath.com. Last updated: 28 January 2019.

Curves can be approximated locally by an arc of a circle. The center and radius of the circle change as we move around the curve. The evolute of a curve is the path traced out by the center of those approximating circles.

You can see some background to this concept in Radius of Curvature, an application of differentiation in the calculus section.

Let's see what this means via some animations.

In the following interactive, you can choose one of the following curves, and see the evolute of each curve traced out as the approximating circle moves around the curve:

1. Ellipse (a "squashed" circle). See more at The Ellipse
2. Nephroid (a kidney-shaped curve, or more technically, a 2-cusped epicycloid)
3. Astroid (a curved diamond shape, or a 4-cusped hypocycloid. Not to be confused with "asteroid", which is a rock hurtling through space)
4. Parabola (a very common curve in mathematics. See more at The Parabola.)

Things to do

Choose any of the 4 curve types and observe how the curve (in green) is approximated by circles that are centered on the evolute (in magenta).

You can choose to show a representative sample of:

1. The approximating circles; and
2. The normals to the curve from the evolute (a normal is a line at right angles to a curve at a point)

The math

This shows how to find the parametric equation of the evolute of an ellipse.

Given a curve with parametric coordinates `(x(t), y(t))`, the parametric equations for its evolute are given by:

`X(t)` `=x(t)` `-\frac {y'(t) (x'(t)^{2}+y'(t)^{2})}{x'(t)\cdot y''(t)-x''(t)\cdot y'(t)}`

`Y(t)` `=y(t)` `+\frac {x'(t)(x'(t)^{2}+y'(t)^{2})}{x'(t)\cdot y''(t)-x''(t)\cdot y'(t)}`

Example: The ellipse example above has parametric equations:

`x(t) = cos t`, `y(t)=2sin t.`

Differentiating with respect to `t` gives:

`x'(t) = -sin t`

`y'(t) = 2cos t`

Differentiating again gives:

`x''(t) = -cos t`

`y''(t) = -2sin t`

Substituting into the above formula for `X(t)` gives the first parametric equation for the evolute as (we're suing the trigonometric identity `sin^2t + cos^2t = 1`):

A similar process gives us the second parametric equation for the evolute:

`Y(t) = - 3 sin^3 t``

The circles

To create the moving circle, we need to know its radius (this will be the radius of curvature for the green curve at each point):

`text(Radius of curvature)` `=([1+((dy)/(dx))^2]^(3//2))/(|(d^2y)/(dx^2)|)`

Now if `x` andf `y` are functions of `t`, we have:

`dy/dx = (dy//dt)/(dx//dt)` and `(d^2y)/(dx^2) = (d^2y//dt^2)/(d^2x//dt^2)`.

So for the ellipse example above, we have:

`dy/dx = (2cost)/(-sint)=-2cot t,` and

`(d^2y)/(dx^2) = (-2sint)/(-cost)=2tant`

For a particular value of `t`, say `t=pi/3`, we have:

`dy/dx = -2 cot {:pi/3:} = -1.1547,` and

`(d^2y)/(dx^2) = 2tan {:pi/3:} = 3.4641`

So the radius of curvature when `t=pi/3` is:

`"radius" = ([1+(-1.1547)^2]^(3//2))/3.4641` ` = 1.0289`

The code

For each of the curves and their evolutes, the following process is involved:

1. Plot the curve (green) and its evolute (magenta) using parametric equations and for loops
2. Create the (light green) circles and give them a class of "displayNone"
3. Create the gray circle that will move around the evolute
4. Create the animation using the center of the gray circle (it will be on the evolute) and the radius of the gray circle (determined using the radius of curvature formula)

Here's the first part of the curve creation part (for the ellipse case, as an example):

// First derivative
function dydx1(x,y) {
  return -4*x/y;    
}
// Second derivative
function d2ydx21(x,y) {
  return Math.abs( (-4 - Math.pow( dydx1(x,y), 2) ) / y );
}    
p = [];
var a=1, b=2;
// Loop to create curve and light green circles
for (t = 0; t < 2*Math.PI+0.2; t += 0.2){
   p.push([a*Math.cos(t), b*Math.sin(t)]);
   // Radius of curvature
   radius = Math.pow(1 + Math.pow(dydx1(a*Math.cos(t), b*Math.sin(t) ), 2 ),  1.5)/d2ydx21(a*Math.cos(t),b*Math.sin(t));
   if ( !isNaN(radius) ) {
     fill = "none";
     strokeopacity = 0.3;
     circID = "circ"+t;
     circle( [(a*a - b*b)/a * Math.pow(Math.cos(t),3), (a*a - b*b)/b * Math.pow(Math.sin(t),3)], radius, circID );
     document.getElementById( circID ).classList.add( "displayNone" );
   }
}

Here's the loop to create the evolute:

for (t = 0; t < 2*Math.PI; t += 0.1){
   p.push([(a*a - b*b)/a * Math.pow(Math.cos(t),3), (a*a - b*b)/b * Math.pow(Math.sin(t),3)]);
}

Credits

Some of the examples and equations come from Wikipedia's Evolute page.