Overview of the Student Vector Calculus Package

All Products Maple MapleSim

Home : Support : Online Help : Applications and Example Worksheets : Calculus : Overview of the Student Vector Calculus Package

Student[VectorCalculus] Package

The Student[VectorCalculus] package is a collection of commands that perform vector calculus computations, and generate related plots and animations. It includes interactive commands that launch point-and-click interfaces to some of the package functionality.

The Student[VectorCalculus] package can be thought of as a simplified version of the full VectorCalculus package. The principal differences are (1) only a limited number of coordinate systems are supported; and (2) commands in the Student[VectorCalculus] package often try to guess the intended coordinate system, or coordinate variable names, while the main VectorCalculus package is stricter in its requirements about being provided these details.

>	$with (Student [VectorCalculus]) &colon;$

Basic Objects

The main objects upon which this package operates are the free vector, the PositionVector, the RootedVector, the VectorField, curves, surfaces, and scalar fields. Lists cannot be used in place of vectors, and scalar fields are ordinary Maple functions and expressions. Information about vector objects - coordinate systems and names of coordinates - are stored as attributes of the vector objects. The About, attributes, and GetCoordinates commands can be used to recover this information.

The free vector is created in one of two ways. The angle-bracket notation creates a free vector in the extant coordinate system. At this point in this worksheet, that coordinate system is Cartesian.

>	$v_{1} := ⟨a, b, c⟩$

$v_{1} := (a) e_{x} + (b) e_{y} + (c) e_{z}$

(1.1)

The explicit use of the Vector command permits attaching coordinates to the free vector.

>	$v_{2} := Vector ([a, b], coordinates = polar [r, θ])$

$v_{2} := (a) e_{r} + (b) e_{θ}$

(1.2)

In each case, the free vector is really a point. In Cartesian coordinates, the free vector $v_{1}$ is a vector from the origin to the point $(a, b, c)$ , and the identification of the point with the free vector is permissible because the unit basis vectors are everywhere parallel.

By analogy, the free vector $v_{2}$ is a point in a rectangular frame with axes labeled $r$ (horizontal) and $θ$ (vertical). In this frame, the point with polar coordinates $(r, θ) = (a, b)$ is connected to the origin with an arrow, and this arrow is $v_{2}$ .

Information about $v_{1}$ and $v_{2}$ is obtained as follows.

>	$About (v_{1})$ $About (v_{2})$

$[\begin{array}{c} Type: & Free Vector \\ Components: & [a, b, c] \\ Coordinates: & cartesian \end{array}]$

$[\begin{array}{c} Type: & Free Vector \\ Components: & [a, b] \\ Coordinates: & {polar}_{r, θ} \end{array}]$

(1.3)

>	$GetCoordinates (v_{1})$ $GetCoordinates (v_{2})$

$cartesian$

${polar}_{r, θ}$

(1.4)

>	$attributes (v_{1})$ $attributes (v_{2})$

$coords = cartesian$

$coords = {polar}_{r, θ}$

(1.5)

The VectorField command is used to create a vector field.

>	$F := VectorField (⟨x^{2}, 1 + x y⟩, cartesian [x, y])$

$F := (x^{2}) {\overset{&lowbar;}{e}}_{x} + (1 + x y) {\overset{&lowbar;}{e}}_{y}$

(1.6)

The unit basis vectors ${\overset{&conjugate0;}{e}}_{x}$ and ${\overset{&conjugate0;}{e}}_{y}$ are used in place of $i$ and $j$ , respectively. The bar denotes that the domain of these basis vectors is the underlying Cartesian space, and that the vectors themselves are position dependent. Of course, in Cartesian coordinates, these basis vectors are independent of position, but the bar is still used to denote that these are the "moving" basis vectors that are defined at each point in the space supporting the vector field, and that are given in the coordinate system in which the vector field is given.

Alternatively, the vector field

>	$G := VectorField (⟨r^{2} \cos (2 θ), r + \sin (θ)⟩, polar [r, θ])$

$G := (r^{2} \cos (2 θ)) {\overset{&lowbar;}{e}}_{r} + (r + \sin (θ)) {\overset{&lowbar;}{e}}_{θ}$

(1.7)

defines a field of vectors whose domain is each point (except for the origin) in the Cartesian plane on which the coordinate curves of the polar coordinate system have been "pulled back." This is the familiar view of polar coordinates superimposed on the Cartesian plane - concentric circles as lines of constant $r$ , and radial rays as lines of constant $θ$ . In this view of the change of coordinates to polar coordinates, the vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ}$ are position dependent. These "moving" basis vectors change direction from point to point, and are not to be confused with the basis vectors appearing in

$v_{2}$

$(a) e_{r} + (b) e_{θ}$

(1.8)

If the evalVF command is used to evaluate the vector field G at a point in the Cartesian plane, the result is a RootedVector. For example, evaluating $G$ at the Cartesian point whose polar-coordinate description is $(r, θ) = (a, b)$ is effected by

>	$G1 := evalVF (G, v_{2})$

$G1 := [\begin{array}{c} a^{2} \cos (2 b) \\ a + \sin (b) \end{array}]$

(1.9)

because the free vector $v_{2}$ is the Maple representation of the point whose polar coordinates are $(a, b)$ . Indeed, we have

>	$About (G1)$

$[\begin{array}{c} Type: & Rooted Vector \\ Components: & [a^{2} \cos (2 b), a + \sin (b)] \\ Coordinates: & {polar}_{r, θ} \\ Root Point: & [a, b] \end{array}]$

(1.10)

The root point is the point of "attachment" for the single vector $G_{1}$ , which is actually a "bound" vector, bound to the root point.

A rooted vector can be defined directly with the RootedVector command.

>	$v_{3} := RootedVector (root = [3, \frac{π}{5}], [α, β], polar [r, θ])$

$v_{3} := [\begin{array}{c} α \\ β \end{array}]$

(1.11)

To verify that this is a vector in polar coordinates, rooted at the polar point $(r, θ) = (3, \frac{π}{5}),$ use

>	$About (v [3])$

$[\begin{array}{c} Type: & Rooted Vector \\ Components: & [α, β] \\ Coordinates: & {polar}_{r, θ} \\ Root Point: & [3, \frac{1}{5} π] \end{array}]$

(1.12)

Information about the rooted vector is actually stored in a module that could be created with the VectorSpace command.

>	$VS := VectorSpace (polar [r, θ], [3, \frac{π}{5}])$

$VS := module () local_origin,_coords,_coords_dim &semi; export GetCoordinates, GetRootPoint, Vector &semi; end module$

(1.13)

The vector space is the set of all vectors of appropriate dimension that have their root point at $(r, θ) = (3, \frac{π}{5}) &period;$ The basis for this vector space is the vectors $\{{\overset{&conjugate0;}{e}}_{r}, {\overset{&conjugate0;}{e}}_{θ}\},$ the moving basis vectors defined at the root point. Individual vectors in this space can be created as module exports via the syntax

>	$v_{4} ≔ VS :- Vector ([α, β])$

$v_{4} := [\begin{array}{c} α \\ β \end{array}]$

(1.14)

That $v_{4}$ is the vector $α {\overset{&conjugate0;}{e}}_{r} + β {\overset{&conjugate0;}{e}}_{θ}$ rooted at the point $(r, θ) = (3, \frac{π}{5})$ can be see with

>	$About (v_{4})$

$[\begin{array}{c} Type: & Rooted Vector \\ Components: & [α, β] \\ Coordinates: & {polar}_{r, θ} \\ Root Point: & [3, \frac{1}{5} π] \end{array}]$

(1.15)

Creating rooted vectors via the VectorSpace command works well when many such vectors will have the same root point. The RootedVector command is most convenient for single rooted vectors.

Finally, there is the PositionVector command that creates the radius-vector form of curves and surfaces. The vectors

>	$R_{1} ≔ PositionVector ([x (t), y (y), z (t)], cartesian [x, y, z]) &colon; R_{2} ≔ PositionVector ([x (a, b), y (a, b), z (a, b)], cartesian [x, y, z]) &colon; R_{1}, R_{2}$

$[\begin{array}{c} x (t) \\ y (y) \\ z (t) \end{array}], [\begin{array}{c} x (a, b) \\ y (a, b) \\ z (a, b) \end{array}]$

(1.16)

are PositionVectors, vectors from the origin of a Cartesian frame to the relevant point in that frame. Points can be parametrized by up to two parameters; a one-parameter family of points represents a curve, and a two-parameter family, a surface. Indeed, we have

>	$About (R_{1})$

$[\begin{array}{c} Type: & Position Vector \\ Components: & [x (t), y (y), z (t)] \\ Coordinates: & {cartesian}_{x, y, z} \\ Root Point: & [0, 0, 0] \end{array}]$

(1.17)

>	$About (R_{2})$

$[\begin{array}{c} Type: & Position Vector \\ Components: & [x (a, b), y (a, b), z (a, b)] \\ Coordinates: & {cartesian}_{x, y, z} \\ Root Point: & [0, 0, 0] \end{array}]$

(1.18)

The PositionVector construct applies only in Cartesian coordinates. The Position Vector

>	$R_{3} ≔ PositionVector ([2 \cos (θ), 2 \sin (θ)], cartesian [x, y])$

$R_{3} := [\begin{array}{c} 2 \cos (θ) \\ 2 \sin (θ) \end{array}]$

(1.19)

describes the origin-centered circle of radius 2 drawn in the Cartesian plane, as we see from

>	$About (R_{3})$

$[\begin{array}{c} Type: & Position Vector \\ Components: & [2 \cos (θ), 2 \sin (θ)] \\ Coordinates: & {cartesian}_{x, y} \\ Root Point: & [0, 0] \end{array}]$

(1.20)

Consequently, in the Cartesian plane the PositionVector, the free vector, and the vector rooted at the origin are essentially the same arrow, but because these are represented in the VectorCalculus package by distinct data structures, they are not necessarily recognized by Maple as being the same. Thus, the package provides the ConvertVector command for converting one form of the Cartesian vector to another.

>	$ConvertVector (R_{1}, free)$

$(x (t)) e_{x} + (y (y)) e_{y} + (z (t)) e_{z}$

(1.21)

>	$ConvertVector (v_{1}, rooted)$

$[\begin{array}{c} a \\ b \\ c \end{array}]$

(1.22)

>	$ConvertVector (v_{1}, position)$

$[\begin{array}{c} a \\ b \\ c \end{array}]$

(1.23)

A final word about the visual display of vectors and vector fields in the VectorCalculus package. The default display for free vectors and vector fields is explicitly in terms of basis vectors. This display can be changed to a column-vector format with the BasisFormat command. The setting

>	$BasisFormat (false) &colon;$

causes the displays to be

>	$v_{1}, F$

$[\begin{array}{c} a \\ b \\ c \end{array}], [\begin{array}{c} x^{2} \\ 1 + x y \end{array}]$

(1.24)

respectively, for a free vector and a vector field. The PositionVector is always displayed as a column vector.

The MapToBasis command imposes a change of coordinates on a vector or vector field. For example, to express the Cartesian vector field

$F$

$[\begin{array}{c} x^{2} \\ 1 + x y \end{array}]$

(1.25)

in polar coordinates, use

>	$simplify (MapToBasis (F, polar [r, θ]))$

$[\begin{array}{c} \sin (θ) + r^{2} \cos (θ) \\ \cos (θ) \end{array}]$

(1.26)

This is equivalent to expressing the unit basis vectors $i$ and $j$ in terms of the vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ},$ then making the substitutions $x = r \cos (θ), y = r \sin (θ)$ . This calculation can be carried out from first principles if the following position vector is first defined.

>	$R := PositionVector ([r \cos (θ), r \sin (θ)], cartesian [x, y])$

$R := [\begin{array}{c} r \cos (θ) \\ r \sin (θ) \end{array}]$

(1.27)

The basis vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ}$ are obtained from R via

>	$Er ≔ diff (R, r)$

$Er := [\begin{array}{c} \cos (θ) \\ \sin (θ) \end{array}]$

(1.28)

>	$Et ≔ Normalize (diff (R, θ)) assuming 0 < r$

$Et := [\begin{array}{c} - \sin (θ) \\ \cos (θ) \end{array}]$

(1.29)

Writing these vectors in terms of $i$ and $j$ can be done with

>	$eq1 := Er &period; ⟨i, j⟩ = er$ $eq2 ≔ Et &period; ⟨i, j⟩ = et$

$eq1 := \cos (θ) i + \sin (θ) j = er$

$eq2 := - \sin (θ) i + \cos (θ) j = et$

(1.30)

Solving for $i$ and $j$ in terms of vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ},$ we get

>	$q := solve (\{eq1, eq2\}, \{i, j\})$

$q := \{i = \frac{- \sin (θ) et + er \cos (θ)}{{\sin (θ)}^{2} + {\cos (θ)}^{2}}, j = \frac{\sin (θ) er + et \cos (θ)}{{\sin (θ)}^{2} + {\cos (θ)}^{2}}\}$

(1.31)

Representing the vector field $F$ in terms of $i$ and $j$ , then replacing $i$ and $j$ with their equivalents in terms of the vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ},$ we get

>	$q1 := simplify (eval (F &period; VectorField (⟨i, j⟩, cartesian [x, y]), q))$

$q1 := - x^{2} \sin (θ) et + x^{2} er \cos (θ) + \sin (θ) er + et \cos (θ) + x y \sin (θ) er + x y et \cos (θ)$

(1.32)

Making the substitutions $x = r \cos (θ), y = r \sin (θ)$ , we get

>	$q2 := simplify (eval (q1, [x = r \cos (θ), y = r \sin (θ)]))$

$q2 := r^{2} er \cos (θ) + \sin (θ) er + et \cos (θ)$

(1.33)

A final rearrangement of terms, and an identification of $er$ and $et$ with vectors ${\overset{&conjugate0;}{e}}_{r}$ and ${\overset{&conjugate0;}{e}}_{θ},$ respectively, gives

>	$q3 := collect (q2, [er, et])$

$q3 := (\sin (θ) + r^{2} \cos (θ)) er + et \cos (θ)$

(1.34)

which compares favorably with

>	$simplify (MapToBasis (F, polar [r, θ]))$

$[\begin{array}{c} \sin (θ) + r^{2} \cos (θ) \\ \cos (θ) \end{array}]$

(1.35)

The MapToBasis command can also be used to transform a point in one coordinate system to its representation in another. Setting

>	$BasisFormat (true) &colon;$

will make the result of

>	$MapToBasis (⟨1, 2⟩, polar [r, t])$

$(\sqrt{5}) e_{r} + (\arctan (2)) e_{t}$

(1.36)

easier to understand. The Cartesian point $(x, y) = (1, 2)$ , represented as a free vector, has been transformed to $(r, θ) = (\sqrt{5}, \arctan (2)),$ also given as a free vector. This is not a vector transformation. The MapToBasis command applies the contravariant transformation law to a rooted vector or a vector field. Applied to a free vector, it transforms just the components. The basis vectors are not so transformed because the free vector is not a vector; it is really just a representation of a point in curvilinear coordinates.

Divergence, Gradient, Curl, and Laplacian

>	$SetCoordinates (cartesian [x, y, z])$

${cartesian}_{x, y, z}$

(2.1)

The Student[VectorCalculus] package contains Divergence, Gradient, Curl, and Laplacian commands.
The Del and Nabla commands are synonyms for the Gradient command.

>	$g := x^{2} + y^{2} + z^{2} &semi;$ $G ≔ Gradient (g) &semi;$ $Del (g) &semi;$ $Nabla (g)$

$g := x^{2} + y^{2} + z^{2}$

$G := 2 x {\overset{&lowbar;}{e}}_{x} + 2 y {\overset{&lowbar;}{e}}_{y} + 2 z {\overset{&lowbar;}{e}}_{z}$

$2 x {\overset{&lowbar;}{e}}_{x} + 2 y {\overset{&lowbar;}{e}}_{y} + 2 z {\overset{&lowbar;}{e}}_{z}$

(2.2)

>	$Divergence (G)$

$6$

(2.3)

>	$Curl (G)$

$0 {\overset{&lowbar;}{e}}_{x}$

(2.4)

>	$Laplacian (g)$

$6$

(2.5)

Space Curves

>	$SetCoordinates (cartesian [x, y, z])$

${cartesian}_{x, y, z}$

(3.1)

The Student[VectorCalculus] package contains space curve commands. Most space curve commands can return a plot or animation.
Consider the following helix.

>	$helix := ⟨\cos (t), \sin (t), t⟩$

$helix := (\cos (t)) e_{x} + (\sin (t)) e_{y} + (t) e_{z}$

(3.2)

To plot the helix, use the SpaceCurve command.
The range of the space curve parameter, in this case 't', must be specified. The axes and scaling options are standard Maple plotting options. For more information about plotting options, see plot/option and plot3d/option.

>	$SpaceCurve (helix, t = 0 .. π, axes = normal, scaling = constrained)$

All the space curve plotting commands have the same syntax: command(space curve definition, options). For some commands you must specify the option output = plot or output = animation to generate visual output.

Using the helix example, calculate the tangent vector (TangentVector)

>	$TangentVector (helix)$

$[\begin{array}{c} - \sin (t) \\ \cos (t) \\ 1 \end{array}]$

(3.3)

Animate the principal normal vector (PrincipalNormal)

>	$PrincipalNormal (helix, output = animation)$

Plot four binormal vectors (Binormal)

>	$Binormal (helix, output = plot, vectors = 4)$

To plot, animate, or compute the unit tangent, normal, and binormal vectors, use the TNBFrame command.

First, plot the unit tangent, normal, and binormal vectors.

>	$TNBFrame (helix, output = plot, scaling = constrained)$

Compute the unit binormal vector.

>	$UnitBinormal = TNBFrame (helix, binormal = true)$

$UnitBinormal = [\begin{array}{c} \frac{1}{2} \sqrt{2} \sin (t) \\ - \frac{1}{2} \sqrt{2} \cos (t) \\ \frac{1}{2} \sqrt{2} \end{array}]$

(3.4)

Plot the unit tangent vector.

>	$TNBFrame (helix, output = plot, tangent = true)$

Create an animation of the unit tangent and binormal vectors.

>	$TNBFrame (helix, output = animation, normal = false)$

To plot the osculating circles of a space curve, use the RadiusOfCurvature command.

>	$RadiusOfCurvature (helix, output = plot, circles = 1, scaling = constrained, axes = normal, range = 0 .. 2 π)$

The package includes other space curve commands that return only values, for example, Curvature and Torsion.

>	$Curvature (helix)$

$\frac{1}{4} \sqrt{2 {\sin (t)}^{2} + 2 {\cos (t)}^{2}} \sqrt{2}$

(3.5)

>	$Torsion (helix)$

$\frac{1}{2}$

(3.6)

All space curve commands that return plots can also plot two-dimensional curves, except the Binormal and RadiusOfCurvature commands.

VectorFields

>	$SetCoordinates (cartesian [x, y])$

${cartesian}_{x, y}$

(4.1)

In addition to Divergence and Curl, VectorFields have two main associated commands: VectorField and FlowLine.

As previously mentioned, the VectorField command creates VectorFields. You can also use it to plot VectorFields.

>	$VectorField (F, output = plot, view = [- 2 .. 2, - 2 .. 2], fieldoptions = [grid = [6, 6]])$

>	$VectorField (F, output = plot, view = [1 .. 6, 2 .. 9])$

The FlowLine command can plot or animate the flow line emanating from a specified starting point.
You can also create an animation that shows the path of an indicator flowing through the vector field along the flow line.

>	$FlowLine (F, ⟨1, 2⟩, output = plot, fieldoptions = [grid = [6, 6]])$

>	$FlowLine (F, ⟨0.1, 0.1⟩, output = animation, fieldoptions = [grid = [6, 6]], view = [- 18 .. 18, - 18 .. 18], scaling = constrained)$

Integration

Using the output = plot option, you can visually represent the integral for a LineInt or Flux command before solving the problem.

The LineInt command computes a line integral, which is also commonly known as a work integral.
The command has four domain types over which it can be integrated: Path, Line, LineSegments, and Circle.
The Circle domain is available only in two dimensions, the others are available in two or three dimensions.

Visually represent a line integral over an ellipse, and compute the integral. Note the direction of the tangent vector.

>	$LineInt (VectorField (⟨y, - x⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 0 .. 2 π), output = plot) &semi;$ $LineInt (VectorField (⟨y, - x⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 0 .. 2 π))$

$- 30 π$

(5.1)

To reverse the direction of the path (and tangent vector), reverse the endpoints of the parameter range in the Path definition.

>	$LineInt (VectorField (⟨y, - x⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 2 π .. 0), output = plot) &semi;$ $LineInt (VectorField (⟨y, - x⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 2 π .. 0))$

$30 π$

(5.2)

You can calculate the flux integral using the Flux command. The domains over which you can integrate are:
(In two dimensions) Circle, Line, LineSegments, and Path
(In three dimensions) Box, Sphere, and Surface
You can specify the direction of the normal vector for Circle, Sphere, and Box domains by including the word 'outward' or 'inward' as the last argument of the domain function. The default value is 'outward'.

Visually represent a flux integral over an ellipse, and compute the integral. Note the direction of the tangent vector.

>	$Flux (VectorField (⟨y, - x + y⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 0 .. 2 π), output = plot) &semi;$ $Flux (VectorField (⟨y, - x + y⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 0 .. 2 π))$

$15 π$

(5.3)

To reverse the direction of the path (and tangent vector), reverse the endpoints of the parameter range in the Path definition.

>	$Flux (VectorField (⟨y, - x + y⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 2 π .. 0), output = plot) &semi;$ $Flux (VectorField (⟨y, - x + y⟩), Path (⟨5 \cos (t), 3 \sin (t)⟩, t = 2 π .. 0))$

$- 15 π$

(5.4)

>	$SetCoordinates (cartesian [x, y, z]) &semi;$ $Flux (VectorField (⟨y, - z, x + z⟩), Box (1 .. 4, 2 .. 6, 1 .. 6), output = plot) &semi;$ $Flux (VectorField (⟨y, - z, x + z⟩), Box (1 .. 4, 2 .. 6, 1 .. 6,' inward'), output = plot)$

${cartesian}_{x, y, z}$

	Interactive Commands
	There are two interactive commands in the Student[VectorCalculus] package: SpaceCurveTutor and VectorFieldTutor. The VectorFieldTutor provides a point-and-click interface to the FlowLine command. The

Maple

Maple 附加模块

MapleSim

MapleSim 附加模块

系统工程

项目服务

Maple T.A. and Möbius

教育

行业

汽车与航空航天

机器人

机器设计和工业自动化

其他

应用领域

产品价格

购买

院系/全校正版授权

Maplesoft精英维护升级计划

支持

产品培训

产品在线帮助

研讨会与活动

出版

资源中心

示例和应用

社区

关于 Maplesoft

媒体中心

用户社区

联系我们

Online Help

All Products Maple MapleSim

Maple

数学软件

Maple 附加模块

MapleSim

多学科系统级建模仿真

MapleSim 附加模块

系统工程

项目服务

Maple T.A. and Möbius

教育

行业

汽车与航空航天

机器人

机器设计和工业自动化

其他

应用领域

产品价格

购买

院系/全校正版授权

Maplesoft精英维护升级计划

支持

产品培训

产品在线帮助

研讨会与活动

出版

资源中心

示例和应用

社区

关于 Maplesoft

媒体中心

用户社区

联系我们

Online Help

All Products Maple MapleSim