Applications, Examples and Libraries

Share your work here

Yes, you read that right! Steps documents are a feature in Maple Learn that we wanted to highlight this week, as they can provide great use in understanding concepts and solving problems. Within them, they can show all steps to solve a problem, including reminders of any formulas used! They can be found at the homepage for steps documents. A list of all can be found below the image, with links.

All steps documents:

All of our documents follow the same format, which I’ll show you using 3 different documents: Derivatives Steps, Factoring Steps, and Matrix Determinant Steps. They will be shown from left to right in that order, so you can see the different steps and how they work.

 

The first thing you’ll see on any steps document is the place to enter the equation. Each equation can be entered in the appropriate box, in different styles to fit your needs and the problem asked.

Then, you click on the show steps button, which is the same for all of the documents:

This is where the magic happens. The steps will appear line by line, in great detail. The actual steps are generated by Maple, and presented in Maple Learn through scripting. Because of this, please don’t click off the group the steps appear in, or they’ll appear in the new group as well!

There are many other steps documents than the ones we have here, and will be adding more as time goes on. Please keep an eye out, and enjoy the updates! We hope this was helpful to you all, and let us know if there are any other steps you’d like to see.

 

Have you ever heard of a matrix kernel or nullspace? If not, or you’d like a refresher on the topic, keep reading! We’re doing a Maple Learn document walkthrough today on Fundamental Subspaces.

The document starts by defining the nullspace/kernel and nullity of a matrix. Nullity is defined as the number of vectors in the basis of the kernel for the given matrix. This makes sense, as nullspace is defined as:

                                    

This may still not make sense to you, and that’s okay! We have an example for a reason, where we try to find a basis for Null(A) and state the dimension of the subspace (nullity).

                                              

I won’t go through the solution here, as trying it yourself is always important. But one hint! If you get really stuck, you can find the Reduced Row Echelon Form (RREF) and the kernel using Maple Learn’s context panel, or check out the rest of our Matrices collection for other helpful documents on this topic.

 

Please let us know what you thought of this walkthrough or if there are any specific documents or topics you’d like to see in the comments below this post. I hope you enjoyed this walkthrough!

We’ve decided to start a new series of blog posts, where we take a closer look at the collections available in Maple Learn. What collection are we looking at first, you ask? Our largest, the Calculus collection! This collection has around 250 documents, and was one of the first to be added to the Maple Learn document gallery.

Because it’s so big, we can’t talk about it all in one post. Instead, we’re going to break it up into three posts: Limits (this one!), Derivatives, and Integration. Keep an eye out for those other ones!

Let’s dive into it. If you’re learning limits for the first time, the first document you’ll want to take a look at is our document on the formal definition of limits.

And of course, just as the document title says, we start with the formal definition of a limit:

From there, like many of our other documents, there’s a visualization to the left, and an explanation to the right. Seems fairly simple, right?

Well, what if you wanted to dig further into the topic?

That’s what the rest of this collection is for! We have documents on many topics relating to limits, such as The Squeeze Theorem, or The Fundamental Trig Limit (don’t forget to use the slider!). We also have a steps document, to help you solve any limits problems you’ve created or found.

We can’t wait to see you another time for when we dive into Derivative documents. Let us know if after the Calculus collection showcase, if you have another collection you’d like to see summarized!

Today I’m here with a document walkthrough under the subject of graph theory! Do you know what an Eulerian path is? Have you ever tried to find one?

An Eulerian path is a path that uses every edge in the graph exactly once. Vertices can be revisited, just not the edges. There are mathematical ways to find an Eulerian path, but at the level of math I’m at, I just use my eyes!

                                                      

In the document Eulerian Paths Quiz, we focus on trying to find an Eulerian path. This document, created using Maple scripting, uses the click on plot feature, allowing you to click on the edges and check your answer. When an edge is clicked, it turns red, and feedback is given.

If you make a mistake, there are a few options. If the most recent edge chosen is the mistake, you can simply click on it again to undo the selection. However, if the mistake is several edges back, or you need to undo the whole thing, you can click the blue reset button.

                                                                                    

Once you’ve done one, you might want to try another graph. That’s why we have a try another button, to give you another random new graph.

We hope you enjoy this document! If you’re curious about how this document was scripted, you can see our script HERE. Please let us know if there are any specific documents you’d like as a walkthrough in the comments below, and check out our other graph theory documents.

For a long time I could not understand how to make a kinematic analysis of this device based on the coupling equations (like here). The equations were drawn up relative to the ends of the grips (horns), that is, relative to the coordinates of 4 points. That's 12 equations. But then only a finite number of mechanism positions take place (as shown by RootFinding[Isolate]). It turns out that there is no continuous transition between these positions. Then it is natural to assume that the movement can be obtained with the help of a small deformation. It seemed that if we discard the condition of a constant distance between the midpoints of the horns (this is the f7 equation at the very beginning), then this will allow us to obtain minimal distortion during movement. In fact, the maximum distortion during the movement was in the second decimal place.
(It seemed that these guys came to a similar result, but analytically "Configuration analysis of the Schatz linkage" C-C Lee and J S Dai
Department of Tool and Die-Making Engineering, National Kaohsiung University of Applied Sciences, Kaohsiung, Taiwan Department of Mechanical Engineering, King’s College, University of London, UK)

The left racks are input.


The first text is used to calculate the trajectory, and the other two show design options based on the data received.
For data transfer, a disk called E is used.
Schatz_mechanism_2_0.mw
OF_experimental_1_part_3_Barrel.mw
OF_experimental_1_part_3.mw

 

Maple Learn is an incredibly powerful tool for math and plotting, but it is made even more powerful when used in combination with Maple! Using scripting tools in Maple, we can make use of hundreds of commands that can solve complex problems for us. In the example of the Lagrange calculator, we are able to use the Maple command LagrangeMultipliers to generate a plot of the two functions and the critical points, even including text feedback about the points.


Something like this seems like it would take hours and a lot of coding knowledge to create, but a simple Maple command generates the entire plot for us! Then, all we had to do was use a button to update the plot. Give it a try yourself in Maple, run the following command with two functions f and g of your choosing:

That’s all there is to it! We now have a complex 3D plot showing the Lagrange problem, something that can be difficult to visualize in multivariate calculus. If we want detailed feedback about the Lagrange problem values, simply change output to detailed from plot:

Check out the entire Maple document (.mw file) to see how the Learn page was generated and to try things out for yourself. This entire document uses the LagrangeMultipliers command, but Maple has hundreds more to experiment with, so the possibilities are virtually limitless!

Share your creations here on MaplePrimes and tag us in your posts.

Maple Learn Document: https://learn.maplesoft.com/doc/lagrange-multipliers-calculator-1biue2ben9

Maple .mw file: https://maple.cloud/app/5998067190071296/LagrangeCalculatorCritical?key=54CE05EC89B34E47984BC61C329A6E759658927BED02458095DA1F576CD93DB9

Maple Learn has a new face! We’ve changed our homepage to the document gallery, which some of you may have already noticed. This is a huge change, and we’re excited for it, as it places content front and center: the goal of Maple Learn. Don’t worry, getting to a blank document is still easy. There is a large orange button on the top right of the document gallery which says “start creating now”. This button will take you to a blank Maple Learn Document.

                                                                        

The most important reason for this change is to help new users get started. Seeing a blank document can sometimes be terrifying! With this new homepage, users can immediately begin looking through premade content, and get inspiration for their own documents.

 

The first document collection a user sees in the document gallery is still the same: Our featured collection. From there, we have the Maple Learn how-to documents, and then it’s into documents sorted by the overarching subject. Two examples of overarching subjects are Functions and Biology. And, if a user is interested in some of the more artistic sides of Maple Learn, we have our art collection available as well. There’s something for everyone in our gallery!

                             

Now that we’ve explained the largest change, let’s talk about some smaller ones too. Tables now can have row and column headings, allowing for a greater range of data to be represented. Along with that, we’ve added a correlation command to the context panel. Some bugs have also been fixed: Special characters now appear properly in the French and German galleries and scrollbars work over 3D plots.

 

We hope you enjoy the changes we’ve made. Please continue to report bugs and telling us about features you’d like to see!

Hi Maple Users

As I hope you have already heard, Maplesoft is having our Maple Conference again this fall. And that means that

Last year we had many great submissions and you can still read about them in detail on the 2021 conference site. Some of the featured works were excellent Maple visualizations, including a special prize for a student contribution by Avek Dongol (center).

But we also featured a number of impressive physical works, including the people's choice winning wood carving by Paul DeMarco (left), and the judges' choice winning cross stitch by Bridjet Lee and Curtis Bright (right).

This year, we are again looking to fill our virtual exhibition with all types of mathematical art, ranging from computer graphics and animations, to needlework, geometrical sculptures, or almost anything you can come up with. Surprise us!

The full announcement can be found at the Maple Conference Art Gallery page. We would like to have all submissions by September 22nd so that we can review and finalize the gallery before the conference begins November 2nd.

I can't wait to see what everyone sends in this year!

This is an interesting exercise, the computation of the Liénard–Wiechert potentials describing the classical electromagnetic field of a moving electric point charge, a problem of a 3rd year undergrad course in Electrodynamics. The calculation is nontrivial and is performed below using the Physics  package, following the presentation in [1] (Landau & Lifshitz "The classical theory of fields"). I have not seen this calculation performed on a computer algebra worksheet before. Thus, this also showcases the more advanced level of symbolic problems that can currently be tackled on a Maple worksheet. At the end, the corresponding document is linked  and with it the computation below can be reproduced. There is also a link to a corresponding PDF file with all the sections open.

Moving charges:
The retarded and Liénard-Wiechert potentials, and the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))`

Freddy Baudine(1), Edgardo S. Cheb-Terrab(2)

(1) Retired, passionate about Mathematics and Physics

(2) Physics, Differential Equations and Mathematical Functions, Maplesoft

 

Generally speaking, determining the electric and magnetic fields of a distribution of charges involves determining the potentials `ϕ` and `#mover(mi("A"),mo("→"))`, followed by determining the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` from

`#mover(mi("E"),mo("→"))` = -(diff(`#mover(mi("A"),mo("→"))`, t))/c-%Gradient(`ϕ`(X)),        `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`)

In turn, the formulation of the equations for `ϕ` and `#mover(mi("A"),mo("→"))` is simple: they follow from the 4D second pair of Maxwell equations, in tensor notation

"`∂`[k](F[]^( i, k))=-(4 Pi)/c j^( i)"

where "F[]^( i, k)" is the electromagnetic field tensor and j^i is the 4D current. After imposing the Lorentz condition

`∂`[i](A^i) = 0,     i.e.    (diff(`ϕ`, t))/c+VectorCalculus[Nabla].`#mover(mi("A"),mo("→"))` = 0

we get

`∂`[k](`∂`[`~k`](A^i)) = 4*Pi*j^i/c

which in 3D form results in

"(∇)^2A-1/(c^2) (((∂)^2)/(∂t^2)( A))=-(4 Pi)/c j"

 

Laplacian(`ϕ`)-(diff(`ϕ`, t, t))/c^2 = -4*Pi*rho/c

where `#mover(mi("j"),mo("→"))` is the current and rho is the charge density.

 

Following the presentation shown in [1] (Landau and Lifshitz, "The classical theory of fields", sec. 62 and 63), below we solve these equations for `ϕ` and `#mover(mi("A"),mo("→"))` resulting in the so-called retarded potentials, then recompute these fields as produced by a charge moving along a given trajectory `#mover(mi("r"),mo("→"))` = r__0(t) - the so-called Liénard-Wiechert potentials - finally computing an explicit form for the corresponding `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))`.

 

While the computation of the generic retarded potentials is, in principle, simple, obtaining their form for a charge moving along a given trajectory `#mover(mi("r"),mo("→"))` = r__0(t), and from there the form of the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` shown in Landau's book, involves nontrivial algebraic manipulations. The presentation below thus also shows a technique to map onto the computer the manipulations typically done with paper and pencil for these problems. To reproduce the contents below, the Maplesoft Physics Updates v.1252 or newer is required.

NULL

with(Physics); Setup(coordinates = Cartesian); with(Vectors)

[coordinatesystems = {X}]

(1)

The retarded potentials phi and `#mover(mi("A"),mo("→"))`

 

 

The equations which determine the scalar and vector potentials of an arbitrary electromagnetic field are input as

CompactDisplay((`ϕ`, rho, A_, j_)(X))

j_(x, y, z, t)*`will now be displayed as`*j_

(2)

%Laplacian(`ϕ`(X))-(diff(`ϕ`(X), t, t))/c^2 = -4*Pi*rho(X)

%Laplacian(varphi(X))-(diff(diff(varphi(X), t), t))/c^2 = -4*Pi*rho(X)

(3)

%Laplacian(A_(X))-(diff(A_(X), t, t))/c^2 = -4*Pi*j_(X)

%Laplacian(A_(X))-(diff(diff(A_(X), t), t))/c^2 = -4*Pi*j_(X)

(4)

The solutions to these inhomogeneous equations are computed as the sum of the solutions for the equations without right-hand side plus a particular solution to the equation with right-hand side.

Computing the solution to the equations for `ϕ`(X) and  `#mover(mi("A"),mo("→"))`(X)

   

The Liénard-Wiechert potentials of a charge moving along `#mover(mi("r"),mo("→"))` = r__0_(t)

 

From (13), the potential at the point X = (x, y, z, t)is determined by the charge e(t-r/c), i.e. by the position of the charge e at the earlier time

`#msup(mi("t"),mo("'",fontweight = "bold"))` = t-LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)/c

The quantityLinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)is the 3D distance from the position of the charge at the time diff(t(x), x) to the 3D point of observationx, y, z. In the previous section, the charge was located at the origin and at rest, so LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) = r, the radial coordinate. If the charge is moving, say on a path r__0_(t), we have

`#mover(mi("R"),mo("→"))` = `#mover(mi("r"),mo("→"))`-r__0_(`#msup(mi("t"),mo("'",fontweight = "bold"))`)

From (13)`ϕ`(r, t) = de(t-r/c)/r and the definition of `#msup(mi("t"),mo("'",fontweight = "bold"))` above, the potential `ϕ`(r, t) of a moving charge can be written as

`ϕ`(r, t(x)) = e/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) and e/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) = e/(c*(t(x)-(diff(t(x), x))))

When the charge is at rest, in the Lorentz gauge we are working, the vector potential is `#mover(mi("A"),mo("→"))` = 0. When the charge is moving, the form of `#mover(mi("A"),mo("→"))` can be found searching for a solution to "(∇)^2A-1/(c^2) (((∂)^2)/(∂t^2)( A))=-(4 Pi)/c j" that gives `#mover(mi("A"),mo("→"))` = 0 when `#mover(mi("v"),mo("→"))` = 0. Following [1], this solution can be written as

"A( )^(alpha)=(e u( )^(alpha))/(`R__beta` u^(beta))" 

where u^mu is the four velocity of the charge, "R^(mu)  =  r^( mu)-`r__0`^(mu)  =  [(r)-(`r__`),c(t-t')]".  

 

Without showing the intermediate steps, [1] presents the three dimensional vectorial form of these potentials `ϕ` and `#mover(mi("A"),mo("→"))` as

 

`ϕ` = e/(R-`#mover(mi("v"),mo("→"))`/c.`#mover(mi("R"),mo("→"))`),   `#mover(mi("A"),mo("→"))` = e*`#mover(mi("v"),mo("→"))`/(c*(R-`#mover(mi("v"),mo("→"))`/c.`#mover(mi("R"),mo("→"))`))

Computing the vectorial form of the Liénard-Wiechert potentials

   

The electric and magnetic fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` of a charge moving along `#mover(mi("r"),mo("→"))` = r__0_(t)

 

The electric and magnetic fields at a point x, y, z, t are calculated from the potentials `ϕ` and `#mover(mi("A"),mo("→"))` through the formulas

 

`#mover(mi("E"),mo("→"))`(x, y, z, t) = -(diff(`#mover(mi("A"),mo("→"))`(x, y, z, t), t))/c-(%Gradient(`ϕ`(X)))(x, y, z, t),        `#mover(mi("H"),mo("→"))`(x, y, z, t) = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`(x, y, z, t))

where, for the case of a charge moving on a path r__0_(t), these potentials were calculated in the previous section as (24) and (18)

`ϕ`(x, y, z, t) = e/(LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)-`#mover(mi("R"),mo("→"))`.(`#mover(mi("v"),mo("→"))`/c))

`#mover(mi("A"),mo("→"))`(x, y, z, t) = e*`#mover(mi("v"),mo("→"))`/(c*(LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)-`#mover(mi("R"),mo("→"))`.(`#mover(mi("v"),mo("→"))`/c)))

These two expressions, however, depend on the time only through the retarded time t__0. This dependence is within `#mover(mi("R"),mo("→"))` = `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_(t__0(x, y, z, t)) and through the velocity of the charge `#mover(mi("v"),mo("→"))`(t__0(x, y, z, t)). So, before performing the differentiations, this dependence on t__0(x, y, z, t) must be taken into account.

CompactDisplay(r_(x, y, z), (E_, H_, t__0)(x, y, z, t))

t__0(x, y, z, t)*`will now be displayed as`*t__0

(29)

R_ = r_(x, y, z)-r__0_(t__0(x, y, z, t)), v_ = v_(t__0(x, y, z, t))

R_ = r_(x, y, z)-r__0_(t__0(X)), v_ = v_(t__0(X))

(30)

The Electric field `#mover(mi("E"),mo("→"))` = -(diff(`#mover(mi("A"),mo("→"))`, t))/c-%Gradient(`ϕ`)

 

Computation of Gradient(`ϕ`(X)) 

Computation of "(∂A)/(∂t)"

   

 Collecting the results of the two previous subsections, we have for the electric field

`#mover(mi("E"),mo("→"))`(X) = -(diff(`#mover(mi("A"),mo("→"))`(X), t))/c-%Gradient(`ϕ`(X))

E_(X) = -(diff(A_(X), t))/c-%Gradient(varphi(X))

(60)

subs(%Gradient(varphi(X)) = -c*e*(-Physics[Vectors][Norm](v_)^2*R_-Physics[Vectors][Norm](R_)*c*v_+R_*c^2+Physics[Vectors][`.`](R_, a_)*R_+Physics[Vectors][`.`](R_, v_)*v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, Physics[Vectors]:-diff(A_(X), t) = e*(Physics[Vectors][Norm](R_)^2*a_*c-v_*Physics[Vectors][Norm](v_)^2*Physics[Vectors][Norm](R_)-Physics[Vectors][Norm](R_)*Physics[Vectors][`.`](R_, v_)*a_+v_*Physics[Vectors][`.`](R_, a_)*Physics[Vectors][Norm](R_)+c*v_*Physics[Vectors][`.`](R_, v_))/((1-Physics[Vectors][`.`](R_, v_)/(Physics[Vectors][Norm](R_)*c))*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_)), E_(X) = -(diff(A_(X), t))/c-%Gradient(varphi(X)))

E_(X) = -e*(Physics:-Vectors:-Norm(R_)^2*a_*c-v_*Physics:-Vectors:-Norm(v_)^2*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`.`(R_, v_)*a_+v_*Physics:-Vectors:-`.`(R_, a_)*Physics:-Vectors:-Norm(R_)+c*v_*Physics:-Vectors:-`.`(R_, v_))/(c*(1-Physics:-Vectors:-`.`(R_, v_)/(Physics:-Vectors:-Norm(R_)*c))*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*e*(-Physics:-Vectors:-Norm(v_)^2*R_-Physics:-Vectors:-Norm(R_)*c*v_+R_*c^2+Physics:-Vectors:-`.`(R_, a_)*R_+Physics:-Vectors:-`.`(R_, v_)*v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(61)

The book, presents this result as equation (63.8):

`#mover(mi("E"),mo("→"))` = e*(1-v^2/c^2)*(`#mover(mi("R"),mo("→"))`-`#mover(mi("v"),mo("→"))`*R/c)/(R-(`#mover(mi("v"),mo("→"))`.`#mover(mi("R"),mo("→"))`)/c)^3+`&x`(e*`#mover(mi("R"),mo("→"))`/c(R-(`#mover(mi("v"),mo("→"))`.`#mover(mi("R"),mo("→"))`)/c)^6, `&x`(`#mover(mi("R"),mo("→"))`-`#mover(mi("v"),mo("→"))`*R/c, `#mover(mi("a"),mo("→"))`))

where `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)). To rewrite (61) as in the above, introduce the two triple vector products

`&x`(R_, `&x`(v_, a_)); expand(%) = %

v_*Physics:-Vectors:-`.`(R_, a_)-Physics:-Vectors:-`.`(R_, v_)*a_ = Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))

(62)

simplify(E_(X) = -e*(Physics[Vectors][Norm](R_)^2*a_*c-v_*Physics[Vectors][Norm](v_)^2*Physics[Vectors][Norm](R_)-Physics[Vectors][Norm](R_)*Physics[Vectors][`.`](R_, v_)*a_+v_*Physics[Vectors][`.`](R_, a_)*Physics[Vectors][Norm](R_)+c*v_*Physics[Vectors][`.`](R_, v_))/(c*(1-Physics[Vectors][`.`](R_, v_)/(Physics[Vectors][Norm](R_)*c))*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*e*(-Physics[Vectors][Norm](v_)^2*R_-Physics[Vectors][Norm](R_)*c*v_+R_*c^2+Physics[Vectors][`.`](R_, a_)*R_+Physics[Vectors][`.`](R_, v_)*v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, {v_*Physics[Vectors][`.`](R_, a_)-Physics[Vectors][`.`](R_, v_)*a_ = Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))})

E_(X) = e*(-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))+R_*c*Physics:-Vectors:-`.`(R_, a_)-Physics:-Vectors:-Norm(R_)^2*a_*c+(-c^2*v_+v_*Physics:-Vectors:-Norm(v_)^2)*Physics:-Vectors:-Norm(R_)+R_*c^3-R_*c*Physics:-Vectors:-Norm(v_)^2)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(63)

`&x`(R_, `&x`(R_, a_)); expand(%) = %

Physics:-Vectors:-`.`(R_, a_)*R_-Physics:-Vectors:-Norm(R_)^2*a_ = Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))

(64)

simplify(E_(X) = e*(-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+R_*c*Physics[Vectors][`.`](R_, a_)-Physics[Vectors][Norm](R_)^2*a_*c+(-c^2*v_+v_*Physics[Vectors][Norm](v_)^2)*Physics[Vectors][Norm](R_)+R_*c^3-R_*c*Physics[Vectors][Norm](v_)^2)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, {Physics[Vectors][`.`](R_, a_)*R_-Physics[Vectors][Norm](R_)^2*a_ = Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))})

E_(X) = (c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))+(c-Physics:-Vectors:-Norm(v_))*(c+Physics:-Vectors:-Norm(v_))*(R_*c-Physics:-Vectors:-Norm(R_)*v_))*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(65)

Split now this result into two terms, one of them involving the acceleration `#mover(mi("a"),mo("→"))`. For that purpose first expand the expression without expanding the cross products

lhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = frontend(expand, [rhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3)])

E_(X) = e*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-Norm(v_)^2*v_/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(R_)*c^2*v_/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(v_)^2*R_*c/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+e*R_*c^3/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+e*c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(66)

Introduce the notation used in the textbook, `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)) and proceed with the splitting

lhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = subs(Norm(R_) = R, Norm(v_) = v, add(normal([selectremove(`not`(has), rhs(E_(X) = e*Physics[Vectors][Norm](R_)*Physics[Vectors][Norm](v_)^2*v_/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](R_)*c^2*v_/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](v_)^2*R_*c/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+e*R_*c^3/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+e*c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3), `#mover(mi("a"),mo("→"))`)])))

E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(R*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))-c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_)))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(67)

Rearrange only the first term using simplify; that can be done in different ways, perhaps the simplest is using subsop

subsop([2, 1] = simplify(op([2, 1], E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics[Vectors][`.`](R_, v_))^3-e*(R*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))-c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_)))/(c*R-Physics[Vectors][`.`](R_, v_))^3)), E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics[Vectors][`.`](R_, v_))^3-e*(R*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))-c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_)))/(c*R-Physics[Vectors][`.`](R_, v_))^3)

E_(X) = e*(c-v)*(c+v)*(-R*v_+R_*c)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(R*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))-c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_)))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(68)

NULL

By eye this result is mathematically equal to equation (63.8) of the textbook, shown here above before (62) .

 

Algebraic manipulation rewriting (68) as the textbook equation (63.8)

   

The magnetic field  `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`)

 

 

The book does not show an explicit form for `#mover(mi("H"),mo("→"))`, it only indicates that it is related to the electric field by the formula

 

`#mover(mi("H"),mo("→"))` = `&x`(`#mover(mi("R"),mo("→"))`, `#mover(mi("E"),mo("→"))`)/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)

 

Thus in this section we compute the explicit form of `#mover(mi("H"),mo("→"))` and show that this relationship mentioned in the book holds. To compute `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`) we proceed as done in the previous sections, the right-hand side should be taken at the previous (retarded) time t__0. For clarity, turn OFF the compact display of functions.

OFF

 

We need to calculate

H_(X) = Curl(A_(x, y, z, t__0(x, y, z, t)))

H_(X) = Physics:-Vectors:-Curl(A_(x, y, z, t__0(X)))

(75)

Deriving the chain rule `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`(t__0(x, y, z, t))) = %Curl(A_(x, y, z, `#msub(mi("t"),mi("0"))`))+`&x`(%Gradient(`#msub(mi("t"),mi("0"))`(X)), diff(`#mover(mi("A"),mo("→"))`(t__0), t__0))

   

So applying to (75)  the chain rule derived in the previous subsection we have

H_(X) = %Curl(A_(x, y, z, t__0))+`&x`(%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0))

H_(X) = %Curl(A_(x, y, z, t__0))+Physics:-Vectors:-`&x`(%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0))

(87)

where t__0 is taken as a function of x, y, z, t only in %Gradient(`#msub(mi("t"),mi("0"))`(X)). Now that the functionality is understood, turning ON the compact display of functions and displaying the fields by their names,

CompactDisplay(H_(X) = %Curl(A_(x, y, z, t__0))+Physics[Vectors][`&x`](%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0)), E_(X))

E_(x, y, z, t)*`will now be displayed as`*E_

(88)

The value of %Gradient(`#msub(mi("t"),mi("0"))`(X)) is computed lines above as (48)

%Gradient(t__0(X)) = R_/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_))

%Gradient(t__0(X)) = R_/(-c*Physics:-Vectors:-Norm(R_)+Physics:-Vectors:-`.`(R_, v_))

(89)

The expression for `#mover(mi("A"),mo("→"))` with no dependency is computed lines above, as (28),

subs(A_ = A_(x, y, z, t__0), A_ = e*v_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_/c))*c))

A_(x, y, z, t__0) = e*v_/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)*c)

(90)

The expressions for `#mover(mi("R"),mo("→"))` and the velocity in terms of t__0 with no dependency are

R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0)

R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0)

(91)

CompactDisplay(r_(x, y, z))

r_(x, y, z)*`will now be displayed as`*r_

(92)

subs(R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0), [%Gradient(t__0(X)) = R_/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_)), A_(x, y, z, t__0) = e*v_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)*c)])

[%Gradient(t__0(X)) = (r_(x, y, z)-r__0_(t__0))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))), A_(x, y, z, t__0) = e*v_(t__0)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c)]

(93)

Introducing this into "H(X)=`%Curl`(A_(x,y,z,t[`0`]))+(`%Gradient`(t[`0`](X)))*((∂A)/(∂`t__0`))",

eval(H_(X) = %Curl(A_(x, y, z, t__0))+Physics[Vectors][`&x`](%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0)), [%Gradient(t__0(X)) = (r_(x, y, z)-r__0_(t__0))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))), A_(x, y, z, t__0) = e*v_(t__0)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c)])

H_(X) = %Curl(e*v_(t__0)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_(t__0), -e*v_(t__0)*(-Physics:-Vectors:-`.`(diff(r__0_(t__0), t__0), r_(x, y, z)-r__0_(t__0))/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-(-Physics:-Vectors:-`.`(diff(r__0_(t__0), t__0), v_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), diff(v_(t__0), t__0)))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)^2*c)+e*(diff(v_(t__0), t__0))/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0)))

(94)

Before computing the first term `&x`(VectorCalculus[Nabla], () .. ()), for readability, re-introduce the velocity diff(`#msub(mi("r"),mi("0_"))`(t__0), t__0) = `#mover(mi("v"),mo("→"))`, the acceleration diff(`#mover(mi("v"),mo("→"))`(t__0), t__0) = `#mover(mi("a"),mo("→"))`, then remove the dependency of these functions on t__0, not relevant anymore since there are no more derivatives with respect to t__0. Performing these substitutions in sequence,

diff(`#msub(mi("r"),mi("0_"))`(t__0), t__0) = `#mover(mi("v"),mo("→"))`, diff(`#mover(mi("v"),mo("→"))`(t__0), t__0) = `#mover(mi("a"),mo("→"))`, `#mover(mi("v"),mo("→"))`(t__0) = `#mover(mi("v"),mo("→"))`, `#msub(mi("r"),mi("0_"))`(t__0) = `#msub(mi("r"),mi("0_"))`

diff(r__0_(t__0), t__0) = v_, diff(v_(t__0), t__0) = a_, v_(t__0) = v_, r__0_(t__0) = r__0_

(95)

subs(diff(r__0_(t__0), t__0) = v_, diff(v_(t__0), t__0) = a_, v_(t__0) = v_, r__0_(t__0) = r__0_, H_(X) = %Curl(e*v_(t__0)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))+Physics[Vectors][`&x`](r_(x, y, z)-r__0_(t__0), -e*v_(t__0)*(-Physics[Vectors][`.`](diff(r__0_(t__0), t__0), r_(x, y, z)-r__0_(t__0))/Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-(-Physics[Vectors][`.`](diff(r__0_(t__0), t__0), v_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), diff(v_(t__0), t__0)))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)^2*c)+e*(diff(v_(t__0), t__0))/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))))

H_(X) = %Curl(e*v_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_, -e*v_*(-Physics:-Vectors:-`.`(v_, r_(x, y, z)-r__0_)/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-(-Physics:-Vectors:-`.`(v_, v_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, a_))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))

(96)

Activate now the inert curl `&x`(VectorCalculus[Nabla], () .. ())

value(H_(X) = %Curl(e*v_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))+Physics[Vectors][`&x`](r_(x, y, z)-r__0_, -e*v_*(-Physics[Vectors][`.`](v_, r_(x, y, z)-r__0_)/Physics[Vectors][Norm](r_(x, y, z)-r__0_)-(-Physics[Vectors][`.`](v_, v_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, a_))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)))

H_(X) = e*Physics:-Vectors:-`&x`(-c^2*_i*Physics:-Vectors:-`.`(diff(r_(x, y, z), x), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_i*Physics:-Vectors:-`.`(diff(r_(x, y, z), x), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2-c^2*_j*Physics:-Vectors:-`.`(diff(r_(x, y, z), y), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_j*Physics:-Vectors:-`.`(diff(r_(x, y, z), y), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2-c^2*_k*Physics:-Vectors:-`.`(diff(r_(x, y, z), z), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_k*Physics:-Vectors:-`.`(diff(r_(x, y, z), z), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2, v_)/c+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_, -e*v_*(-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-(-Physics:-Vectors:-Norm(v_)^2+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, a_))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))

(97)

From (34)diff(`#mover(mi("r"),mo("→"))`, x) = `#mover(mi("i"),mo("∧"))`, diff(`#mover(mi("r"),mo("→"))`, y) = `#mover(mi("j"),mo("∧"))`, diff(`#mover(mi("r"),mo("→"))`, z) = `#mover(mi("k"),mo("∧"))`, and reintroducing `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_ = `#mover(mi("R"),mo("→"))`

subs(diff(r_(x, y, z), x) = _i, diff(r_(x, y, z), y) = _j, diff(r_(x, y, z), z) = _k, `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_ = `#mover(mi("R"),mo("→"))`, H_(X) = e*Physics[Vectors][`&x`](-c^2*_i*Physics[Vectors][`.`](diff(r_(x, y, z), x), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_i*Physics[Vectors][`.`](diff(r_(x, y, z), x), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2-c^2*_j*Physics[Vectors][`.`](diff(r_(x, y, z), y), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_j*Physics[Vectors][`.`](diff(r_(x, y, z), y), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2-c^2*_k*Physics[Vectors][`.`](diff(r_(x, y, z), z), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_k*Physics[Vectors][`.`](diff(r_(x, y, z), z), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2, v_)/c+Physics[Vectors][`&x`](r_(x, y, z)-r__0_, -e*v_*(-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/Physics[Vectors][Norm](r_(x, y, z)-r__0_)-(-Physics[Vectors][Norm](v_)^2+Physics[Vectors][`.`](r_(x, y, z)-r__0_, a_))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)))

H_(X) = e*Physics:-Vectors:-`&x`(-c^2*_i*Physics:-Vectors:-`.`(_i, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_i*Physics:-Vectors:-`.`(_i, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2-c^2*_j*Physics:-Vectors:-`.`(_j, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_j*Physics:-Vectors:-`.`(_j, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2-c^2*_k*Physics:-Vectors:-`.`(_k, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_k*Physics:-Vectors:-`.`(_k, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2, v_)/c+Physics:-Vectors:-`&x`(R_, -e*v_*(-Physics:-Vectors:-`.`(R_, v_)/Physics:-Vectors:-Norm(R_)-(-Physics:-Vectors:-Norm(v_)^2+Physics:-Vectors:-`.`(R_, a_))/c)/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(R_)+Physics:-Vectors:-`.`(R_, v_))

(98)

Simplify(H_(X) = e*Physics[Vectors][`&x`](-c^2*_i*Physics[Vectors][`.`](_i, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_i*Physics[Vectors][`.`](_i, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2-c^2*_j*Physics[Vectors][`.`](_j, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_j*Physics[Vectors][`.`](_j, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2-c^2*_k*Physics[Vectors][`.`](_k, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_k*Physics[Vectors][`.`](_k, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2, v_)/c+Physics[Vectors][`&x`](R_, -e*v_*(-Physics[Vectors][`.`](R_, v_)/Physics[Vectors][Norm](R_)-(-Physics[Vectors][Norm](v_)^2+Physics[Vectors][`.`](R_, a_))/c)/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)*c))/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_)))

H_(X) = (-e*c*Physics:-Vectors:-`&x`(R_, v_)*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))+e*(-c*Physics:-Vectors:-`.`(R_, v_)+(Physics:-Vectors:-Norm(v_)^2-Physics:-Vectors:-`.`(R_, a_))*Physics:-Vectors:-Norm(R_))*Physics:-Vectors:-`&x`(R_, v_)-e*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, a_))/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3*Physics:-Vectors:-Norm(R_))

(99)

To conclude, rearrange this expression as done with the one for the electric field `#mover(mi("E"),mo("→"))` at (65), so first expand  (99) without expanding the cross products

lhs(H_(X) = (-e*c*Physics[Vectors][`&x`](R_, v_)*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))+e*(-c*Physics[Vectors][`.`](R_, v_)+(Physics[Vectors][Norm](v_)^2-Physics[Vectors][`.`](R_, a_))*Physics[Vectors][Norm](R_))*Physics[Vectors][`&x`](R_, v_)-e*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_))/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3*Physics[Vectors][Norm](R_))) = frontend(expand, [rhs(H_(X) = (-e*c*Physics[Vectors][`&x`](R_, v_)*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))+e*(-c*Physics[Vectors][`.`](R_, v_)+(Physics[Vectors][Norm](v_)^2-Physics[Vectors][`.`](R_, a_))*Physics[Vectors][Norm](R_))*Physics[Vectors][`&x`](R_, v_)-e*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_))/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3*Physics[Vectors][Norm](R_)))])

H_(X) = -Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, a_)*c*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+Physics:-Vectors:-`&x`(R_, v_)*Physics:-Vectors:-Norm(v_)^2*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-Physics:-Vectors:-`&x`(R_, v_)*c^2*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+Physics:-Vectors:-`.`(R_, v_)*Physics:-Vectors:-`&x`(R_, a_)*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-Physics:-Vectors:-`&x`(R_, v_)*Physics:-Vectors:-`.`(R_, a_)*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(100)

Then introduce the notation used in the textbook, `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)) and split into two terms, one of which contains the acceleration `#mover(mi("a"),mo("→"))`

lhs(H_(X) = -Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_)*c*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][Norm](v_)^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*c^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`.`](R_, v_)*Physics[Vectors][`&x`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][`.`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = subs(Norm(R_) = R, Norm(v_) = v, add(normal([selectremove(`not`(has), rhs(H_(X) = -Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_)*c*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][Norm](v_)^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*c^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`.`](R_, v_)*Physics[Vectors][`&x`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][`.`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3), `#mover(mi("a"),mo("→"))`)])))

H_(X) = Physics:-Vectors:-`&x`(R_, v_)*e*(-c^2+v^2)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(Physics:-Vectors:-`&x`(R_, a_)*R*c-Physics:-Vectors:-`&x`(R_, a_)*Physics:-Vectors:-`.`(R_, v_)+Physics:-Vectors:-`.`(R_, a_)*Physics:-Vectors:-`&x`(R_, v_))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(101)

Verifying `#mover(mi("H"),mo("→"))` = `&x`(`#mover(mi("R"),mo("→"))`, `#mover(mi("E"),mo("→"))`)/R

   

References

 

NULL

[1] Landau, L.D., and Lifshitz, E.M. Course of Theoretical Physics Vol 2, The Classical Theory of Fields. Elsevier, 1975.

NULL

 

Download document: The_field_of_moving_charges.mw

Download PDF with sections open: The_field_of_moving_charges.pdf

 

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

It’s been a hot week at the Maplesoft office, but we’re back with another fun example! In school, you probably learned how to calculate volume of simple shapes: Cubes, prisms, things like that. However, something I never understood was complex shapes. I struggled to separate it into smaller shapes, plus I had trouble understanding ratios!

                                                          

Thankfully, Maple Learn has documents on almost anything. I love looking through them when making these posts, just to see what more I can learn. In this case, I found a really interesting example on Changing Dimensions and Effects on Volume, which taught me a lot. Let’s take a look at it, and hopefully it will help you too!

 

The document begins with a statement, saying “For a 3D object, if one or more dimensions (length, width, height) are changed, then the volume of the object is scaled by a factor equal to the product of all scale factors of changed dimensions”. If you’re not a math person, like me, this statement can be quite confusing at first glance. Let’s break it down.

 

The first part of the statement is easy to understand. We know what a 3D object is, and we know what dimensions changing means. We also know what the volume of an object is, as a concept. However, what is all this about scale factors?

 

Looking at the example, it starts to make a lot more sense. The solid has dimensions of 4x10x6. To find the scale factor, we first need to decide on an “original” solid. In this case, a 2x2x2 cube. The number of those cubes is found by dividing each dimension of the full shape by the dimensions of the original shape. This gives us 30. That means the new solid is 30 times larger than the cubes.

 

From there, the document has a fun, interactive example that lets you play around with sliders.

                                                          

When you change a, b, and c you are changing the scale factors. This lets you see the final volume, and how it changes with those factors.

 

We hope this example helped you understand a concept you may have never been directly taught, as I know it helped me! Let us know if you’d like to see any more example walkthroughs.

Happy Friday everyone, and welcome to our third post about how you can use Maple Learn in non-math disciplines! Today, we’re going to talk about the Biology collection in Maple Learn. This was a recent addition to the Maple Learn document gallery.

Of course, there are too many documents in the Biology collection to talk about all of them. We’re going to talk about three documents today, and I’ll link to them as we go. Are you excited? I am!

First, let’s talk about the Introduction to Alleles and Genotype document. The current focus of our Biology collection is genetics. This document is therefore important to start with as it lays the foundation for understanding the rest of the documents. Using a visualization of a sperm cell and an egg cell, this document clearly explains what alleles and genotypes are, and how this presents in humans and other diploid organisms.

`

Next is the Introduction to Punnett Squares. Punnett squares are used to predict genotypes and the probability of those genotypes existing in an organism. They can be pretty fun, once you get the hang of them, and are simple to understand using this document. We use the table feature in Maple Learn to display the Punnett squares, which is quite a handy feature for visualizations.

Finally, although there are other introductory documents (Phenotypes, Dihybrid crosses), let’s take a look at the Blood Typing document! As you may know, there are four main blood types (when you exclude the positive or negative): A, B, AB, and O. However, there are only three alleles, due to codominance and other factors. Come check out how this works, and read the document yourself!

                                                                        

Our Biology collection is still growing, and we’d love to hear your input. Let us know in the comments of this post if there are any other document topics you’d like to see!

Here's a procedure using GraphTheory by morphing one four letter word into another by changing only one letter at a time.  This is my initial working version.  I've commented out the DrawGraph portion as it takes a long time (5 minutes or so) to produce.  Using the Neighbors command from the GraphTheory package the graph can be shrunk to only include the relevant paths and will take a shorter time to draw.  It's an initial version so there is room for improvements.
 

a := readdata("c:/sowpods.txt", string)NULL

with(StringTools)NULL

b := [seq(`if`(length(a[i]) = 4, a[i], NULL), i = 1 .. nops(a))]

NULL

The word morph procedure for 4 letter words.

NULL

morph := proc (w1::string, w2::string) local c, i, q, d, r, j, k, g, gg, sp; c := {seq(`if`(HammingDistance(w1, b[i]) = 1, b[i], NULL), i = 1 .. nops(b))}; q := {seq(`if`(HammingDistance(w2, b[i]) = 1, b[i], NULL), i = 1 .. nops(b))}; for i to nops(c) do c || i := {seq(`if`(HammingDistance(c[i], b[j]) = 1, b[j], NULL), j = 1 .. nops(b))} end do; for i to nops(q) do q || i := {seq(`if`(HammingDistance(q[i], b[j]) = 1, b[j], NULL), j = 1 .. nops(b))} end do; d := map(proc (x) options operator, arrow; {x, w1} end proc, c); r := map(proc (x) options operator, arrow; {x, w2} end proc, q); for i to nops(c) do d || i := map(proc (x) options operator, arrow; {c[i], x} end proc, c || i) end do; for i to nops(q) do r || i := map(proc (x) options operator, arrow; {q[i], x} end proc, q || i) end do; for k to nops(c) do for j to nops(c || k) do c || k || _ || j := {seq(`if`(HammingDistance(c || k[j], b[i]) = 1, b[i], NULL), i = 1 .. nops(b))} end do end do; for k to nops(q) do for j to nops(q || k) do q || k || _ || j := {seq(`if`(HammingDistance(q || k[j], b[i]) = 1, b[i], NULL), i = 1 .. nops(b))} end do end do; for i to nops(c) do for j to nops(c || i) do d || i || _ || j := map(proc (x) options operator, arrow; {c || i[j], x} end proc, c || i || _ || j) end do end do; for i to nops(q) do for j to nops(q || i) do r || i || _ || j := map(proc (x) options operator, arrow; {q || i[j], x} end proc, q || i || _ || j) end do end do; g := {d[], r[], seq(d || i[], i = 1 .. nops(c)), seq(r || k[], k = 1 .. nops(q)), seq(seq(d || j || _ || i[], i = 1 .. nops(c || j)), j = 1 .. nops(c)), seq(seq(r || j || _ || i[], i = 1 .. nops(q || j)), j = 1 .. nops(q))}; gg := GraphTheory:-Graph(g); sp := GraphTheory:-ShortestPath(gg, w1, w2); print(sp) end proc
Today, June 6 is international yoyo day.  So I start off with, of course, the word yoyo.

NULL

morph("yoyo", "four")

["yoyo", "boyo", "boys", "foys", "fous", "four"]

(1)

morph("door", "yoyo")

["door", "boor", "boos", "boys", "boyo", "yoyo"]

(2)

morph("four", "yoyo")

["four", "fous", "foys", "boys", "boyo", "yoyo"]

(3)

morph("zane", "quit")

["zane", "cane", "cant", "cunt", "cuit", "quit"]

(4)

morph("lair", "jump")

["lair", "gair", "gaur", "gaup", "gamp", "gump", "jump"]

(5)

morph("jump", "lair")

["jump", "gump", "gamp", "gaup", "gaur", "gair", "lair"]

(6)

morph("quit", "jump")

["quit", "luit", "lunt", "luna", "luma", "lump", "jump"]

(7)

morph("xray", "jump")

Error, (in GraphTheory:-ShortestPath) no path from xray to jump exists

 

NULL

With no path another level of iteration word groups will be needed.  Otherwise you can use an intermediate word as below

NULL

morph("xray", "door")

["xray", "dray", "drab", "doab", "doob", "door"]

(8)

morph("door", "jump")

["door", "poor", "poop", "pomp", "pump", "jump"]

(9)

morph("lair", "door")

["lair", "loir", "loor", "door"]

(10)

NULL

NULL


 

Download Word_Morph_3.mw

Word_Morph.maple

Last week, we took a look at the Chemistry documents in Maple Learn. After writing that post, I started thinking more about the types of documents we have in the document gallery. From there, I realized we’d made several updates to the Physics collection, and added a Biology collection, that I hadn’t written about yet! So, this week, we’ll be talking about the Physics collection, and next week, we’ll have a discussion about the Biology collection. Without further ado, let’s take a look!

First, let’s talk Kinematics. This collection has been around for a while now, and if you’ve looked at the Physics documents, you’ve likely seen it. We have documents for Displacement, Velocity, and Acceleration, Equations 1 to 4 for Kinematics, 1D motion, and 2D motion. Let’s take a look at the 2D motion example, shall we?

In this document, we explore projectile motion. You can use sliders to change the initial velocity and the height of a projectile, in order to see how they affect the object’s motion. Then, in group two, you can adjust the number of seconds after an object has been released in order to see how the velocity changes. The resulting graph is shown above this paragraph.

Next, we also have documents on Energy, Simple Harmonic Motion, and Waves (interference and harmonics). These documents were added over the last few months, and we’re excited to share them! Opening the document used as an example for wave harmonics (link provided again here), we’re immediately given a description of the important background knowledge, and then a visualization, shown below. This allows you to see how waves change based on the harmonics and over time.

Finally, we have documents on Electricity and Magnetism, Dynamics, and some miscellaneous documents, like our document on the inverse square law applied to Gravity. Within these document collections, we have quizzes, information, and many more visualizations!

The Physics collection is quite an interesting collection, we hope you enjoy! As with the Chemistry documents, please let us know if there’s any topics you’d like to see in our document gallery.

Hello Maple Learn enthusiasts, of all disciplines! Do any of you study Chemistry, or simply enjoy it? Well, you’re in luck. We’re released a new collection of documents in the document gallery, all focused on Chemistry. Remember, Maple Learn isn’t just for math fields. We also have documents on Biology, Physics, Finance, and much more!

                                                                  

First, we have our new gas laws documents. These documents focus on Boyle’s law, Charles’ law, Gay-Lussac’s law, and Avogadro’s law. We also have documents on the Combined Gas law and the Ideal Gas law. Many of these laws also have example questions to go along with them, for your studying needs.

We also have documents on molar and atomic mass. One example for atomic mass teaches you to use the proper formulas (No spoilers for the answer here, folks!) using the material Hafnium and its five isotopes. Don’t know the approximate masses of the isotopes without looking them up? No worries, I don’t either! It’s in the question text, as a hint.

Finally, let’s take a look at the dilution documents. We have documents discussing the calculations, and some examples. In this document, there are both an example walking you through the steps, and a practice question for you to try yourself. Of course, the solution is included at the bottom of the document, but we encourage you to try the problem yourself first.

We hope you’re just as excited as us for the Chemistry collection! Like our other collections, the Chemistry collection is constantly being added to. If you have any ideas for future documents, or even just topics you’d like to see, let us know in the comments below.

Today is a very exciting day at Maplesoft! Yesterday, we released Sumzle on the Maple Calculator app. Of course, this might not mean anything to you yet, because, well, what is Sumzle? Don’t worry, we know you’re asking. So, without waiting any longer, let’s take a look.

Sumzle is a math game, inspired by the Wordle craze, where you attempt to guess an equation. Each guess:

  • Must include an equal sign
  • Must include up to two operators
  • May include a blank column

Sumzle’s interface looks like this:

After each guess, the tile’s colors change to reflect how correct the guess was. Green means that the tile is in the right spot, yellow means the tile is in the equation but the wrong spot, and grey means that it is not in the equation. Let me show you the progression of a game, on the Fun difficulty.

Sumzle can be played once a day on the free tier. For unlimited games, you can subscribe to Maple Calculator Premium or ask your friends to challenge you!

 

Math games are for everyone, and Sumzle has three levels of difficulty. Are you interested in the history of Sumzle? I sure am!

Sumzle was originally designed by Marek Krzeminski, a MapleSim developer. He had called it Mathie and showed the game to his colleagues here at Maplesoft. Well, we loved it!

After a few months of discussion and development, we tweaked the game to create Sumzle. Honestly, the hardest part was naming the game! We had so many great suggestions, such as Mathstermind and Addle. Eventually, we put it to a vote, and Sumzle rose above the rest.

We hope you enjoy the game, because Math not only matters, but is fun. Don’t forget to update your Maple Calculator app in order to receive that game, as otherwise you won’t be able to find it. Next time you need a break, we challenge you to a game of Sumzle!

4 5 6 7 8 9 10 Last Page 6 of 71