Computing Line Integrals\302\251 2006 Mike May, S.J.- maymk@slu.eduWhen working with line integrals, we will use the Student[VectorCalculus] package. It has nice commands to evaluate line integrals. To help our understanding, it seems worthwhile to go through using Maple to set up and evaluate line integrals over a parameterized curve in a step by step process, labeling all the intermediate steps. We will then produce new procedures that do everything in one command. We then note the Student[VectorCalculus] package commands that give the answer directly. We also want to set a technical condition, specifying that the vector fields will be written as vectors rather than as linear combinations of basis vectors.restart:
with(Student[VectorCalculus]);
BasisFormat(false):
<Text-field style="Heading 2" layout="Heading 2">A step by step example</Text-field>First we need to define a vector field that we want to integrate, the parameterized path we are integrating over, and the limits on the parameter. For our example we will use the familiar circular vector field and integrate over half an ellipse.F := <-y,x>;
VF := VectorField(F);
C := <3*cos(2*t), 2*sin(2*t)>;
trange := t=0..Pi/2;The process of integrating the line integral over the parameterized curve can be broken into 6 steps:1) Plot a graph of the vector field and the parameterized curve.2) Substitute the parameterization of the path into the field to make the field a vector valued function of the parameter.3) Take the derivative of the path with respect to the parameter.4) Evaluate the dot product and simplify. This reduces the problem to an integral over an interval.5) Set up the line integral with the integrand being the dot product of the vector field and the derivative of the parameterized path.6) Evaluate the integral.We are ready to walk through the steps one at a time. As we work through the example with Maple, you should make sure that you can also do each step by hand.The first step is to look at a graph of the vector field and the parameterized curve.P1 := VectorField(F, output=plot,view=[-4..4,-1..4], color=red):
P2 := SpaceCurve(C,trange, color=blue):
plots[display]({P1,P2}, axes=boxed, scaling =constrained);The second step is to replace x and y and the vector field with the parameterizations of x and y at the appropriate point on the path.FonC := evalVF(VF,C);The third step is to take the derivative of the parameterized path.R := diff(C,t);The fourth step is to evaluate the dot product in the integrand and simplify.integrand1 := FonC.R;
integrand := simplify(integrand1):
print("The integrand is ", integrand);The next step is to set up the line integralInt(integrand, trange);We now evaluate the integral and evaluate the result numerically, if needed.intval := int(integrand, trange);
evalf(intval);
<Text-field style="Heading 2" layout="Heading 2">An automated approach</Text-field>For convenience we block the code into two procedures, one for plotting, and one for setting up the integral and evaluating it. This allows us to modify the problem with a minimal amount of work.pathplot := proc(vecfield, path, trange, window)
local vfieldplot, parampath;
vfieldplot := VectorField(vecfield,output=plot,view=window):
parampath := SpaceCurve(path,trange, color=black):
plots[display]({vfieldplot, parampath});
end:
lineintegral:= proc(vecfield, path, trange)
local intval, paramfield, dpath, integrand;
print("the vector field is ", vecfield);
print("the path is ", path, " with ", trange);
print(Int((vecfield.Diff(path,t)), trange));
paramfield := evalVF(VectorField(vecfield), path);
print("the function on the path is ", paramfield);
print(Int((paramfield.Diff(path,t)), trange));
dpath := diff(path, t);
print("the derivative of the path is ", diff(path, t));
print(Int((paramfield.dpath), trange));
integrand := simplify(paramfield.dpath):
print("The integrand is ", integrand);
print(Int(integrand, trange));
intval := int(integrand, trange);
print("the integral is ", intval);
print(evalf(intval));
end:Thus, we can get results by entering the vectorfield and path and executing the two commands.SetCoordinates( cartesian[x,y] ):
vfield := <-y,x>;
path := <1+3*cos(t), -4+2*sin(t)>;
trange := t=0..Pi;
pathplot(vfield, path, trange, [-5..5, -5..5]);
lineintegral(vfield, path, trange);It should be noted that if all we want is the final answer, the VectorCalculus package has a LineInt command that can be used to plot the curve and field, set up the integral, and give the final answer.LineInt(VectorField(vfield), Path(path, trange),output=plot);
LineInt(VectorField(vfield), Path(path, trange),output=integral);
LineInt(VectorField(vfield), Path(path, trange));
<Text-field style="Heading 2" layout="Heading 2">Exercises:</Text-field>1) Evaluate the line integral where F = [ln(y), ln(x)] and C is the curve given parametrically by [2t, t^2] with t=2..4.2) Evaluate the line integral where F = [2y, -sin(y)] and C is the unit circle traced in a counterclockwise directions from the point (1, 0).3) Evaluate the line integral where F = e^x i + e^y j and C is the part of the ellipse x^2 + 4y^2 = 4 from the point (0, 1) to the point (2, 0) in a clockwise direction.
<Text-field style="Heading 2" layout="Heading 2">Line Integrals in 3-D</Text-field>If the vector field is in three dimensions, we need to slightly modify the lineintegral command. In that case we will not plot the curve.lineintegral3d:= proc(vecfield, path, trange)
local intval, paramfield, dpath, integrand;
print("the vector field ", vecfield);
print("the path ", path, " with ", trange);
print(Int((vecfield.Diff(path,t)), trange));
paramfield := evalVF(VectorField(vecfield), path);
print("the function on the path is ", paramfield);
print(Int((paramfield.Diff(path,t)), trange));
dpath := diff(path, t);
print("the derivative of the path is ", diff(path, t));
print(Int((paramfield.dpath), trange));
integrand := simplify(paramfield.dpath):
print("The integrand is ", integrand);
print(Int(integrand, trange));
intval := int(integrand, trange);
print("the integral is ", intval);
print(evalf(intval));
end:Using this command we redo example 4 from the text. Note that we have to specify that we are changing the coordinate system. (To go back to 2D we will need use SetCoordinates( cartesian[x,y]): )SetCoordinates( cartesian[x,y,z] ):
vfield := <x, z, -x*y>;
path := <cos(t), sin(t), 2*t>;
trange := t=0..3*Pi;
lineintegral3d(vfield, path, trange);Once again, if all we want is the final answer, the VectorCalculus package has a LineInt command.LineInt(VectorField(vfield), Path(path, trange), output=plot);
LineInt(VectorField(vfield), Path(path, trange), output=integral);
LineInt(VectorField(vfield), Path(path, trange));
<Text-field style="Heading 2" layout="Heading 2">Exercise:</Text-field>4) Evaluate the line integral where F = -y i + x j + 5 k and C is the helix [cos(t), sin(t) t] for t=0..4Pi.TTdSMApJM1JUQUJMRV9TQVZFLzExNTA2MFgqJSlhbnl0aGluZ0c2Ii8lJ2Nvb3Jkc0clKmNhcnRlc2lhbkdbZ2whIyUhISEiIyIjLCQlInlHISIiJSJ4RzYiTTdSMApJM1JUQUJMRV9TQVZFLzg5MTU4OFgqJSlhbnl0aGluZ0c2IjYkJSx2ZWN0b3JmaWVsZEcvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCRGLiEiIkYtNiI=TTdSMApJM1JUQUJMRV9TQVZFLzg5MTY2OFgqJSlhbnl0aGluZ0c2Ii8lJ2Nvb3Jkc0clKmNhcnRlc2lhbkdbZ2whIyUhISEiIyIjLCQtJSRjb3NHNiMsJCUidEciIiMiIiQsJC0lJHNpbkdGLEYvNiI=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TTdSMApJNFJUQUJMRV9TQVZFLzUwMDMxMzJYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCYiIiJGLi0lJGNvc0c2IyUidEciIiQsJiEiJUYuLSUkc2luR0YxIiIjNiI=TTdSMApJNFJUQUJMRV9TQVZFLzY2MjgwNjhYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCRGLCEiIkYrNiI=TTdSMApJNFJUQUJMRV9TQVZFLzUwMDMxMzJYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCYiIiJGLi0lJGNvc0c2IyUidEciIiQsJiEiJUYuLSUkc2luR0YxIiIjNiI=TTdSMApJNFJUQUJMRV9TQVZFLzY2MjgwNjhYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCRGLCEiIkYrNiI=TTdSMApJNFJUQUJMRV9TQVZFLzUwMDMxMzJYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCYiIiJGLi0lJGNvc0c2IyUidEciIiQsJiEiJUYuLSUkc2luR0YxIiIjNiI=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TTdSMApJNFJUQUJMRV9TQVZFLzUwMDMxMzJYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYkJSJ4RyUieUdbZ2whIyUhISEiIyIjLCYiIiJGLi0lJGNvc0c2IyUidEciIiQsJiEiJUYuLSUkc2luR0YxIiIjNiI=TTdSMApJM1JUQUJMRV9TQVZFLzg5MDk4OFgqJSlhbnl0aGluZ0c2IjYjLyUnY29vcmRzRyYlKmNhcnRlc2lhbkc2JCUieEclInlHW2dsISMlISEhIiMiIywkLSUkc2luRzYjJSJ0RyEiJCwkLSUkY29zR0YxIiIjNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQ4MDA0MTZYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJEYrRi0sJComRisiIiJGLEYwISIiNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQzODI3ODRYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJC0lJGNvc0c2IyUidEctJSRzaW5HRjAsJEYxIiIjNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQ4MDA0MTZYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJEYrRi0sJComRisiIiJGLEYwISIiNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQzODI3ODRYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJC0lJGNvc0c2IyUidEctJSRzaW5HRjAsJEYxIiIjNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQ4MDA0MTZYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJEYrRi0sJComRisiIiJGLEYwISIiNiI=TTdSMApJNFJUQUJMRV9TQVZFLzQzODI3ODRYKiUpYW55dGhpbmdHNiIvJSdjb29yZHNHJiUqY2FydGVzaWFuRzYlJSJ4RyUieUclInpHW2dsISMlISEhIiQiJC0lJGNvc0c2IyUidEctJSRzaW5HRjAsJEYxIiIjNiI=M7R0
I4RTABLE_SAVE/4562640X*%)anythingG6"6#/%&spaceG`6%I/GetCoordinatesf*6"F-F-F-OT#F-F-6$%(_coordsG%(_coordsGF-I-GetRootPointf*F-F-F-F-O-_%/VectorCalculusG%'VectorG6$F//.%'coordsGT%F-F-6&%(_originG%(_originGF1F2F-I'Vectorf*6#'%+componentsG%%listG6&%"fG%"vGF=%&namesGF-F-C(>8&-F/F-@$-%%typeG6$FN.%(indexedGC$>8'7#-%#opG6#FN>FN-Fen6$""!FNZ%@&/FN.%*cartesianG@$3-%)assignedG6#FX0-%%nopsGFdo-Fgo6#9$YF-0F>FhoYF-F-YQ]pthe~dimension~of~the~Vector~must~match~the~dimension~of~the~underlying~VectorSpaceF-@%-FR6$9!FT>8$&_F-F96#-Fen6#Fcp>FepFgp>8%-Fep6$Fjo/.%+attributesG7#/.F(T(OF]qF-F-6(%/GetCoordinatesGF+%,_coords_dimG%,_coords_dimG%+thismoduleGF)F-b6#F\r6%F@F1FjqF-6%Fiq%-GetRootPointGF9F-F-F-6(%)incoordsG%)incoordsG%-incoords_dimG%-incoords_dimG%)inoriginG%)inoriginG%*_m6611424G6%FAF2F[r[gl!#%!!!"$"$-I$cosf*6#'%"xG%*algebraicG6&I$resGF-I"nGF-I"tGF-I$tmpGF-6%/%(builtinG%+HFloat_cosG-%(automapG6#"""IaoCopyright~(c)~1992~by~the~University~of~Waterloo.~All~rights~reserved.GF-k[sR,$%"uG!""-F\s6#FbtI"uGF--F\s6#Fft-%$sinG6#%"tG-F\s6#FitI#t|irGF--F\s6#F_u-F\sF[u-F\s6#Fbu,$%#PiG#""$""#Fjn,&%(limit/XGFctFfuFhu,$-F\s6#F[vFctI"tGF--F\s6#F_vI"uGF--F\s6#Fbv,$%"uGFct-F\s6#Ffv,$%"tGFct-F\s6#Fjv,$F_vFctF`v,$FesFctF[sI"uGF--F\s6#F_w,$FbvFctFcv,$FitFctF]u,$%"uGFct-F\s6#FewFfvFgv,&F[vF^tFfu!"$F\vI"tGF--F\s6#Fjw,&F[vF^tFfuF^tF\vF\uFbuF[vF]vI#t|irGF--F\s6#F^xFewFfw,$Ffu#F^t"#5-F\s6#Fax,$FftFctFgt-FjtFav-F\s6#Fgx,$F^xFctF_x,&F[vF^tFfuFctF\v,$F_uFctF`u,$Fes!"#-F\s6#,$FesFiu,$%#t|irGFct-F\s6#FcyFjvF[w,$%#t|irGFct-F\s6#Fgy,$%#_XGFct-F\s6#F[z,$F[vFctF]vFbtFdtF[zF\z,$FgxFctFhx,$FjwFctF[x,&F[vFctFfuF^tF\v,$F_wFctF`wFcyFdyFayF_yFesF[sFgyFhy,$FbuFctFcu,$F\uFctFbu*FjnF^tFfuFct,$Ffu#F^t""%,$*$Fiu#F^tFiuFjz,$Ffu#F^t""',$*$FhuFjzFjz,$FfuFjzFjnI)infinityG%*protectedGI*undefinedGFb[l^#F^t-%%coshG6#F^t,$Ffu#F^tFhuFjz,$Fa[lFctFc[lC$@A09#F^tY6$Q=expecting~1~argument,~got~%1F-F^\l-FR6$9$.-%(complexG6#%&floatGO-%&evalfG6#-.F\s6#Fd\l-FR6$Fd\l.Fa[l@%-FR6$-%#ReGF`]lFc]l>8$-%#ifG6%-FR6$-%#ImGF`]l.Fc[l-_%-NumericToolsG%/ThrowUndefinedGF`]l*&Fd\lF^tFc[lF^t>Fj]l*$Fd\lFgz-FR6$Fd\lFb^l@%-FR6$Fd\l.%*imaginaryG>Fj]lF`^l>Fj]l-Fd^l6$Fd\l/.%)preserveG.%%realG3-FR6$Fd\l.%1SymbolicInfinityG/-%*traperrorG6#-%#isG6$Fd\lFi_l%%trueG>Fj]lFc[l5F]_l3-FR6$Fd\l%"*G-%'memberG6$Ff`l-%$mapG6%FR<#-FenF`]lF__l>Fj]l-Ff[l6#*&^#FctF^tFd\lF^t-FR6$Fd\l.-Fg\l6#%(numericG@%2-%%csgnGF`]lFjn>Fj]l-F\s6#,$Fd\lFct>Fj]lF^]l33Fj`l-FR6$-Fen6$F^tFd\lF\bl2-Fcbl6#F]clFjn>Fj]lFebl3Fj`l-FR6$Fd\l.-%#&*G6$%)rationalG-%*identicalG6#FfuC$>8&F]cl@)2F`dl#F^tFiu>Fj]lF^]l2F`dlF^t>Fj]l,$-F\s6#*&,&F^tF^tF`dlFctF^tFfuF^tFct2F`dlFiu>Fj]l-F\s6#*&,&FiuF^tF`dlFctF^tFfuF^t>Fj]l-F\s6#*&,&F`dlF^t-%%iquoG6$-%&truncG6#F`dlFiuF^yF^tFfuF^t3-FR6$Fd\l%"+G/-Fa`l6#-%%signGF`]lFct>Fj]lFebl3F^fl-%$hasG6$Fd\lFfuC$>F`dl-Faal6$f*6#F`sF-F-F-@$-FR6$*&FjoF^tFfuFct.FjclFdglF-F-F-Fcal@%/-FgoF\flF^tC$>F`dl-FenF\fl@+2F`dlFjn>Fj]l-F\s6#,(Fd\lF^t*&FfuF^t-F[fl6#,$F`dlFcdlF^tF^yFfuFiuFbdlC%>-F\sF`]l.Fhhl>8'-9!Ffbl@%0-Fen6$FjnF[ilF]ilC$>Fj]lF[il/FhhlFj]l>Fj]lFihlFedl>Fj]l,$-Fjt6#,&Fd\lF^tFfu#FctFiuFctF\el>Fj]l,$-F\s6#,&Fd\lF^tFfuFctFct>Fj]l-F\s6#,&Fd\lF^tFbhlF^y>Fj]l-%+cos/normalGF`]l33Fj`l-F^al6%Ffu7#Fdal.8%/F`^lFjnC%>F`dl-%'subsopG6$/F^[mF^tFd\l>F^[m-%%fracGF\fl@+/-Fh[mFdhlFjn>Fj]lF^t/-Fh[m6#,&F`dlFcdlF[jlF^tFjn>Fj]lFct/F^[mFjn>Fj]l)FctF`dl/-Fh[m6#,&F`dlF^tF[jlF^tFjn>Fj]lFjn>Fj]lFfjl3-FR6$Fd\l.%)functionG/-FgoF`]lF^tC%>F^[m-Fen6$FjnFd\l>F`dlF]cl@//F^[m.%'arcsinG>Fj]l-%%sqrtG6#,&F^tF^t*$F`dlFiuFct/F^[m.%'arccosG>Fj]lF`dl/F^[m.%'arctanG>Fj]l*$-F]^m6#,&F^tF^tF`^mF^tFct/F^[m.%'arccscG>Fj]l-F]^m6#,&F^tF^t*$F`dlF^yFct/F^[m.%'arcsecG>Fj]l*$F`dlFct/F^[m.%'arccotG>Fj]l*&F`dlF^tFj^mFct>Fj]lFfjl-FR6$Fd\l-.%)specfuncG6$.F$.%)JacobiAMG>Fj]l-%)JacobiCNG6#Fdal-FR6$Fd\l.-Fg^m6$FasFas>Fj]l*&-Fen6$FiuFd\lF^t-F]^m6#,&*$F]clFiuF^t*$FdamFiuF^tFctC%>Fj]lFfjl>F[il-%2trig/linear_in_PiGF`]l@$0F[ilFd\lC$>F[il-F]il6#F[il@$0F`il.F]ilC$>Fj]lF[il>6$FhhlFebl6$Fj]lFj]l>-F\s6#9"Fj]l6"FbcmFbcm6$Fb[lI(_syslibGF-6#FesFay,$*&F[sF^t-FjtFecmF^tFctF-M7R0
I4RTABLE_SAVE/4562640X*%)anythingG6"6#/%&spaceG`6%I/GetCoordinatesf*6"F-F-F-OT#F-F-6$%(_coordsG%(_coordsGF-I-GetRootPointf*F-F-F-F-O-_%/VectorCalculusG%'VectorG6$F//.%'coordsGT%F-F-6&%(_originG%(_originGF1F2F-I'Vectorf*6#'%+componentsG%%listG6&%"fG%"vGF=%&namesGF-F-C(>8&-F/F-@$-%%typeG6$FN.%(indexedGC$>8'7#-%#opG6#FN>FN-Fen6$""!FNZ%@&/FN.%*cartesianG@$3-%)assignedG6#FX0-%%nopsGFdo-Fgo6#9$YF-0F>FhoYF-F-YQ]pthe~dimension~of~the~Vector~must~match~the~dimension~of~the~underlying~VectorSpaceF-@%-FR6$9!FT>8$&_F-F96#-Fen6#Fcp>FepFgp>8%-Fep6$Fjo/.%+attributesG7#/.F(T(OF]qF-F-6(%/GetCoordinatesGF+%,_coords_dimG%,_coords_dimG%+thismoduleGF)F-b6#F\r6%F@F1FjqF-6%Fiq%-GetRootPointGF9F-F-F-6(%)incoordsG%)incoordsG%-incoords_dimG%-incoords_dimG%)inoriginG%)inoriginG%*_m6611424G6%FAF2F[r[gl!#%!!!"$"$-I$cosf*6#'%"xG%*algebraicG6&I$resGF-I"nGF-I"tGF-I$tmpGF-6%/%(builtinG%+HFloat_cosG-%(automapG6#"""IaoCopyright~(c)~1992~by~the~University~of~Waterloo.~All~rights~reserved.GF-k[sR,$%"uG!""-F\s6#FbtI"uGF--F\s6#Fft-%$sinG6#%"tG-F\s6#FitI#t|irGF--F\s6#F_u-F\sF[u-F\s6#Fbu,$%#PiG#""$""#Fjn,&%(limit/XGFctFfuFhu,$-F\s6#F[vFctI"tGF--F\s6#F_vI"uGF--F\s6#Fbv,$%"uGFct-F\s6#Ffv,$%"tGFct-F\s6#Fjv,$F_vFctF`v,$FesFctF[sI"uGF--F\s6#F_w,$FbvFctFcv,$FitFctF]u,$%"uGFct-F\s6#FewFfvFgv,&F[vF^tFfu!"$F\vI"tGF--F\s6#Fjw,&F[vF^tFfuF^tF\vF\uFbuF[vF]vI#t|irGF--F\s6#F^xFewFfw,$Ffu#F^t"#5-F\s6#Fax,$FftFctFgt-FjtFav-F\s6#Fgx,$F^xFctF_x,&F[vF^tFfuFctF\v,$F_uFctF`u,$Fes!"#-F\s6#,$FesFiu,$%#t|irGFct-F\s6#FcyFjvF[w,$%#t|irGFct-F\s6#Fgy,$%#_XGFct-F\s6#F[z,$F[vFctF]vFbtFdtF[zF\z,$FgxFctFhx,$FjwFctF[x,&F[vFctFfuF^tF\v,$F_wFctF`wFcyFdyFayF_yFesF[sFgyFhy,$FbuFctFcu,$F\uFctFbu*FjnF^tFfuFct,$Ffu#F^t""%,$*$Fiu#F^tFiuFjz,$Ffu#F^t""',$*$FhuFjzFjz,$FfuFjzFjnI)infinityG%*protectedGI*undefinedGFb[l^#F^t-%%coshG6#F^t,$Ffu#F^tFhuFjz,$Fa[lFctFc[lC$@A09#F^tY6$Q=expecting~1~argument,~got~%1F-F^\l-FR6$9$.-%(complexG6#%&floatGO-%&evalfG6#-.F\s6#Fd\l-FR6$Fd\l.Fa[l@%-FR6$-%#ReGF`]lFc]l>8$-%#ifG6%-FR6$-%#ImGF`]l.Fc[l-_%-NumericToolsG%/ThrowUndefinedGF`]l*&Fd\lF^tFc[lF^t>Fj]l*$Fd\lFgz-FR6$Fd\lFb^l@%-FR6$Fd\l.%*imaginaryG>Fj]lF`^l>Fj]l-Fd^l6$Fd\l/.%)preserveG.%%realG3-FR6$Fd\l.%1SymbolicInfinityG/-%*traperrorG6#-%#isG6$Fd\lFi_l%%trueG>Fj]lFc[l5F]_l3-FR6$Fd\l%"*G-%'memberG6$Ff`l-%$mapG6%FR<#-FenF`]lF__l>Fj]l-Ff[l6#*&^#FctF^tFd\lF^t-FR6$Fd\l.-Fg\l6#%(numericG@%2-%%csgnGF`]lFjn>Fj]l-F\s6#,$Fd\lFct>Fj]lF^]l33Fj`l-FR6$-Fen6$F^tFd\lF\bl2-Fcbl6#F]clFjn>Fj]lFebl3Fj`l-FR6$Fd\l.-%#&*G6$%)rationalG-%*identicalG6#FfuC$>8&F]cl@)2F`dl#F^tFiu>Fj]lF^]l2F`dlF^t>Fj]l,$-F\s6#*&,&F^tF^tF`dlFctF^tFfuF^tFct2F`dlFiu>Fj]l-F\s6#*&,&FiuF^tF`dlFctF^tFfuF^t>Fj]l-F\s6#*&,&F`dlF^t-%%iquoG6$-%&truncG6#F`dlFiuF^yF^tFfuF^t3-FR6$Fd\l%"+G/-Fa`l6#-%%signGF`]lFct>Fj]lFebl3F^fl-%$hasG6$Fd\lFfuC$>F`dl-Faal6$f*6#F`sF-F-F-@$-FR6$*&FjoF^tFfuFct.FjclFdglF-F-F-Fcal@%/-FgoF\flF^tC$>F`dl-FenF\fl@+2F`dlFjn>Fj]l-F\s6#,(Fd\lF^t*&FfuF^t-F[fl6#,$F`dlFcdlF^tF^yFfuFiuFbdlC%>-F\sF`]l.Fhhl>8'-9!Ffbl@%0-Fen6$FjnF[ilF]ilC$>Fj]lF[il/FhhlFj]l>Fj]lFihlFedl>Fj]l,$-Fjt6#,&Fd\lF^tFfu#FctFiuFctF\el>Fj]l,$-F\s6#,&Fd\lF^tFfuFctFct>Fj]l-F\s6#,&Fd\lF^tFbhlF^y>Fj]l-%+cos/normalGF`]l33Fj`l-F^al6%Ffu7#Fdal.8%/F`^lFjnC%>F`dl-%'subsopG6$/F^[mF^tFd\l>F^[m-%%fracGF\fl@+/-Fh[mFdhlFjn>Fj]lF^t/-Fh[m6#,&F`dlFcdlF[jlF^tFjn>Fj]lFct/F^[mFjn>Fj]l)FctF`dl/-Fh[m6#,&F`dlF^tF[jlF^tFjn>Fj]lFjn>Fj]lFfjl3-FR6$Fd\l.%)functionG/-FgoF`]lF^tC%>F^[m-Fen6$FjnFd\l>F`dlF]cl@//F^[m.%'arcsinG>Fj]l-%%sqrtG6#,&F^tF^t*$F`dlFiuFct/F^[m.%'arccosG>Fj]lF`dl/F^[m.%'arctanG>Fj]l*$-F]^m6#,&F^tF^tF`^mF^tFct/F^[m.%'arccscG>Fj]l-F]^m6#,&F^tF^t*$F`dlF^yFct/F^[m.%'arcsecG>Fj]l*$F`dlFct/F^[m.%'arccotG>Fj]l*&F`dlF^tFj^mFct>Fj]lFfjl-FR6$Fd\l-.%)specfuncG6$.F$.%)JacobiAMG>Fj]l-%)JacobiCNG6#Fdal-FR6$Fd\l.-Fg^m6$FasFas>Fj]l*&-Fen6$FiuFd\lF^t-F]^m6#,&*$F]clFiuF^t*$FdamFiuF^tFctC%>Fj]lFfjl>F[il-%2trig/linear_in_PiGF`]l@$0F[ilFd\lC$>F[il-F]il6#F[il@$0F`il.F]ilC$>Fj]lF[il>6$FhhlFebl6$Fj]lFj]l>-F\s6#9"Fj]l6"FbcmFbcm6$Fb[lI(_syslibGF-6#FesFay,$*&F[sF^t-FjtFecmF^tFctF-M7R0
I4RTABLE_SAVE/4382784X*%)anythingG6"/%'coordsG&%*cartesianG6%%"xG%"yG%"zG[gl!#%!!!"$"$-%$cosG6#%"tG-%$sinGF0,$F1""#6"TTdSMApJNFJUQUJMRV9TQVZFLzcyNTc3OTJYKiUpYW55dGhpbmdHNiI2Iy8lJ2Nvb3Jkc0cmJSpjYXJ0ZXNpYW5HNiUlInhHJSJ5RyUiekdbZ2whIyUhISEiJCIkLCQtJSRzaW5HNiMlInRHISIiLSUkY29zR0YyIiIjNiI=