Another service from Omega

Computing Line Integrals with Maple


*****

Exercises


Problem1:


Compute the line integral

> #

                                   /
                                  |
                                  |  sin(x) dx
                                  |
                                 / C

where C is the arc of the curve x=y^4 from (1,-1) to (1,1).

Solution1:


If we use the parametrization:

> y := t; x := t^4; dx := diff(x,t); dy := diff(y,t);

                                     y := t

                                          4
                                    x := t

                                            3
                                   dx := 4 t

                                    dy := 1

here and in the rest of these problems dx and dy stand for the derivatives with respecto to t of x and y respectively and not for the usual differential that would include the additional multiplication by dt.

The line integral is then:

> ans1 := Int(sin(x)*dx,t=-1..1)=int(sin(x)*dx,t=-1..1);

                                  1
                                  /
                                 |         4   3
                        ans1 :=  |  4 sin(t ) t  dt = 0
                                 |
                                /
                                -1

Notice that the integral is trivially 0 since we are integrating an odd function over a symmetric (about 0) domain i.e. [-1,1].

Problem2:


Before the statement of the next problem let us write a little proc for cleanning up the variables quickly:

> clean := proc()
> global x,y,z,dx,dy,dz;
> x :='x': y:='y' : z:= 'z':
> dx := 'dx': dy := 'dy' : dz := 'dz':
> end:

Now we are ready for problem2: Compute

> clean():
> Int(y*z*dx + x*z*dy + x*y*dz,t);

                          /
                         |
                         |  y z dx + x z dy + x y dz 
                         |
                        / C

where C consists of the line segments from the origin to (1,1,2), from (1,1,2) to (2,-1,2) and from (2,-1,2) back to the origin. i.e. a triangle!

Solution2:


First split the integral into 3 parts I1,I2 and I3 along each of the three segments. The answer is just I1+I2+I3. We need to parametrize each segment. The first segment from (0,0,0) to (1,1,2) is:

> with(linalg): r := evalm([0,0,0]+t*([1,1,2]-[0,0,0]));

                               r := [ t, t, 2 t ]
> x:=r[1]; y:=r[2]; z:=r[3]; dx:=diff(x,t);dy:=diff(y,t);dz:=diff(z,t);
                                     x := t

                                     y := t

                                    z := 2 t

                                    dx := 1

                                    dy := 1

                                    dz := 2

(don't forget what we said above about the dx,dy...) so the integral is:

> I1 := Int(y*z*dx + x*z*dy + x*y*dz,t=0..1) =
> int(y*z*dx + x*z*dy + x*y*dz,t=0..1);

                                     1
                                     /
                                    |     2
                             I1 :=  |  6 t  dt = 2
                                    |
                                   /
                                   0

Now the second segment from (1,1,2) to (2,-1,2):

> r := evalm([1,1,2]+t*([2,-1,2]-[1,1,2]));

                           r := [ 1 + t, 1 - 2 t, 2 ]
> x:=r[1]; y:=r[2]; z:=r[3]; dx:=diff(x,t);dy:=diff(y,t);dz:=diff(z,t);
                                   x := 1 + t

                                  y := 1 - 2 t

                                     z := 2

                                    dx := 1

                                    dy := -2

                                    dz := 0
> I2 := Int(y*z*dx + x*z*dy + x*y*dz,t=0..1) =
> int(y*z*dx + x*z*dy + x*y*dz,t=0..1);
                                  1
                                  /
                                 |
                          I2 :=  |  - 2 - 8 t dt = -6
                                 |
                                /
                                0

and finally the last segment from (2,-1,2) to (0,0,0) is:

> r:=evalm([2,-1,2]+t*[-2,1,-2]);

                       r := [ 2 - 2 t, - 1 + t, 2 - 2 t ]
> x:=r[1]; y:=r[2]; z:=r[3]; dx:=diff(x,t);dy:=diff(y,t);dz:=diff(z,t);
                                  x := 2 - 2 t

                                  y := - 1 + t

                                  z := 2 - 2 t

                                    dx := -2

                                    dy := 1

                                    dz := -2
> I3 := Int(y*z*dx + x*z*dy + x*y*dz,t=0..1) =
> int(y*z*dx + x*z*dy + x*y*dz,t=0..1);
                     1
                     /
                    |                                     2
             I3 :=  |  - 4 (- 1 + t) (2 - 2 t) + (2 - 2 t)  dt = 4
                    |
                   /
                   0

The integral over the whole boundary of the triangle is then:

> ans2 := I1+I2+I3;

ans2 :=

     1             1                  1
     /             /                  /
    |     2       |                  |                                     2
    |  6 t  dt +  |  - 2 - 8 t dt +  |  - 4 (- 1 + t) (2 - 2 t) + (2 - 2 t)  dt
    |             |                  |
   /             /                  /
   0             0                  0

    = 0

Hmmm all this work to get 0? Well.. in fact we'd be able to deduce that the answer is zero if we knew that F=[yz,xz,xy] is a conservative vector field (since its curl is 0) and that line integrals of conservative vector fields over close paths are always 0.

Problem3:


Compute the work done by the force field F=[x,y+2] in moving an object along an arch (t from 0 to 2Pi) of the cycloid:

> r :=evalm([t-sin(t),1-cos(t)]);

                        r := [ t - sin(t), 1 - cos(t) ]


Solution3:


The cycloid is given by:

> x:=r[1];y:=r[2];dx:=diff(x,t);dy:=diff(y,t);

                                x := t - sin(t)

                                y := 1 - cos(t)

                                dx := 1 - cos(t)

                                  dy := sin(t)
> ans3 := Int(x*dx+(y+2)*dy,t=0..2*Pi) = int(x*dx+(y+2)*dy,t=0..2*Pi);
             2 Pi
              /
             |                                                             2
    ans3 :=  |    (t - sin(t)) (1 - cos(t)) + (3 - cos(t)) sin(t) dt = 2 Pi
             |
            /
            0


Problem4:


Write a maple procedure for computing the line integral of a vector field F over a parametrized curve r. Call it lint.

Solution4:


Here it is. lint expects a vector F (of dim 2 or 3) with expressions in x,y and z, a vector r with expressions in a parameter (usually t) and a range for the parameter like t=a..b (see examples below).

> lint := proc(F,r,range)
> local t,a,b,P,Q,R,dx,dy,dz,Li,li,f;
> global x,y,z;
> t := eval(op(1,range));
> a := op(1,op(2,range));
> b := op(2,op(2,range));
> x := r[1];
> dx := diff(x,t);
> y := r[2];
> dy := diff(y,t);
> if nops(linalg[evalm](F)) = 2 then z := 0; dz := 0; R := 0
> else z := r[3]; dz := diff(z,t); R := F[3]
> fi;
> Q := F[2];
> P := F[1];
> f := eval(P*dx+Q*dy+R*dz);
> Li := Int(P*'dx'+Q*'dy'+R*'dz',oes);
> li := int(f,t = a .. b);
> x := 'x';
> y := 'y';
> z := 'z';
> RETURN(Li = li)
> end;

lint := proc(F,r,range)
        local t,a,b,P,Q,R,dx,dy,dz,Li,li,f;
        global x,y,z;
            t := eval(op(1,range));
            a := op(1,op(2,range));
            b := op(2,op(2,range));
            x := r[1];
            dx := diff(x,t);
            y := r[2];
            dy := diff(y,t);
            if nops(linalg[evalm](F)) = 2 then z := 0; dz := 0; R := 0
            else z := r[3]; dz := diff(z,t); R := F[3]
            fi;
            Q := F[2];
            P := F[1];
            f := eval(P*dx+Q*dy+R*dz);
            Li := Int(P*'dx'+Q*'dy'+R*'dz',oes);
            li := int(f,t = a .. b);
            x := 'x';
            y := 'y';
            z := 'z';
            RETURN(Li = li)
        end

Let's try it with problem 3.

> lint([x,y+2,0],[t-sin(t),1-cos(t),0],t=0..2*Pi);

                 /
                |                                               2
                |  (t - sin(t)) dx + (3 - cos(t)) dy does = 2 Pi
                |
               /

Let's try it again with I3 of problem 2:

> r := [2-2*t,t-1,2-2*t]: F := [y*z,x*z,x*y]:
> lint(F,r,t=0..1);

                       /
                      |
                      |  y z dx + x z dy + x y dz does = 4
                      |
                     /

I like lint.. don't you?
But wait isn't the above proc unnecessarily long?... You bet! Lint below does it in any number of dimensions and it is only 1 instruction. We need, however, to give F and r as funcitons instead of just vectors of expressions.

> Lint := proc(F,r,range)
> local t;
> t := op(1,range);
> int(linalg[innerprod](F(op(r(t))),map(diff,r(t),t)),range)
> end;

Lint := proc(F,r,range)
        local t;
            t := op(1,range);
            int(linalg[innerprod](F(op(r(t))),map(diff,r(t),t)),range)
        end
> F := unapply(F,x,y,z); r := unapply(r,t);
                        F := (x,y,z) -> [y z, x z, x y]

                     r := t -> [2 - 2 t, - 1 + t, 2 - 2 t]
> Lint(F,r,t=a..b);
                             3       2             3       2
                   12 b + 4 b  - 12 b  - 12 a - 4 a  + 12 a
> Lint(F,r,t=0..1);
                                       4

Cool!


Link to the commands in this file
Carlos Rodriguez <carlos@math.albany.edu>
Last modified: Wed Nov 27 17:13:22 EST 1996