MaplePrimes Posts

MaplePrimes Posts are for sharing your experiences, techniques and opinions about Maple, MapleSim and related products, as well as general interests in math and computing.

Latest Post
  • Latest Posts Feed
  • 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!

    MapleSim is a mature product. The rich component library leaves little room for improvement for wide range of applications. It is understandable that latest product releases focused on specialized toolboxes and performance improvements.

    Here is what I think could be beneficial for many users, which is not related to performance, but can help improve the user experience:

    1. Crossing connection lines: A view option to render a crossing connection line with an arc at the crossing point of two connection lines of the same type. Right-click on a connection line might be enough.
       

      -> To avoid misinterpretations of routing in crowded model diagrams
       
    2. Parameters: An option to populate or reset changes in the parameter pane to the parameter default settings view and vice versa

      -> When testing or optimizing a model, sometimes changed parameters should become default values or be reset. Doing this manually is error prone and takes time.
       
    3. Component flip: Selecting more than one component including connection lines and applying a flip to all of them

      -> When building a model, it can happen that a nicely laid out arrangement of components needs to be mirrored or rotated in its entirety. Doing this component by component and connection by connection is a lot of work that can be saved by this option.
       
    4. Initial conditions: An option in the view menu to highlight components where ICs have been changed from ignore to treat as guess or to strictly enforce
       

      -> ICs are set for many purposes. In addition to defining ICs needed for simulations, this can include extracting equations, testing different model states, or temporarily "immobilizing" a model during assembly, to name a few. Undoing a tentative change can easily be forgotten. Combining existing models that work on their own into a new more complex model often results in an overly constrained model that either cannot be assembled or does not simulate.
      In debugging a model, ICs of all components must be individually inspected. This takes time. A quick overview that shows components where ICs are not set to ignore would be very helpful in debugging models.
       
    5. Undo Create subsystem: A reverse operation that inserts the contents of a subsystem into a parent subsystem.

      -> With the evolution of a model it is sometimes useful to exclude or include existing components from or to a subsystem. For this purpose, an undo create subsystem operation should preserve existing connections. A time saver.
       
    6. Subsystem ports: An option to align a subsystem port to the drawing grid to remove “micro” steps in connection lines
       

      -> For perfectionists who do not have the time to learn (and remember) how to fine-tune at the component level
       
    7. A history or log function of user actions changing a model, its parametrization or internal state.

      -> Often a model does not simulate at all or as desired after modifications. Restoring to a configuration that worked by undo only goes back to the last simulation performed. In such a situation, only reloading the latest file version and redoing modifications may restore the desired model, parametrization, or state. This takes time and migth be unsuccessful. A record of user actions would be a great help.
      History or log information in file format could also help MapleSim support to reproduce an error.

    For me personally, reducing errors (4. > 7. > 2.) would improve the use experience much more than layouting aids (3. > 1., 5., 6.).

    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.

    We have just released an update to Maple, Maple 2022.1.

    Maple 2022.1 includes improvements to the math engine, Plot Builder, Print Layout mode, and more.  We strongly recommend that all Maple 2022 users install these updates.

    This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2022.1 download page, where you can also find more details.

    In particular, please note that this update includes fixes to problems with Units:-Simple (here and here), evala, sum, and deleting tasks from a task template, all reported on MaplePrimes. As always, thanks for the feedback!

    We are happy to announce that we released MapleSim 2022 today.

    The MapleSim 2022 family of products offers improvements in modeling and connectivity, including many that are in direct response to customer requests. Improvements include:

    • Reduce diagram clutter by using “wireless” To-From blocks for a larger variety of signals
    • Easily create, customize, and fine-tune control valves with new components and tools in the hydraulics library
    • Expand modeling scope with improvements to several specialized libraries and toolboxes, including the MapleSim add-on products for Battery, Heat Transfer, and Web Handling
    • New productivity and connectivity features in MapleSim Insight,  a standalone product in the MapleSim family that gives machine builders powerful simulation-based debugging and 3-D visualization capabilities that connect directly to your automation tools

     

    See What’s New in MapleSim 2022 for more information about these and other improvements.

    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!

    We are holding another Maple Conference this year, and I am pleased to announce that we have just opened the Call for Participation!

    This year’s conference will be held Nov. 2 – Nov. 3, 2022. It will be a free virtual event again this year, and it will be an excellent opportunity to meet other members of the Maple community and share your work.

    We are inviting submissions of presentation proposals on a range of topics related to Maple, including Maple in education, algorithms and software, and applications. We also encourage submission of proposals related to Maple Learn. This year, we are not requiring recorded videos, and we hope to see more interaction between presenters and audience members in our live sessions.

    You can find more information about the themes of the conference and how to submit a presentation proposal at the Call for Participation page. Proposals are due July 18, 2022.

    Presenters will have the option to submit papers and articles to a special Maple Conference issue of the Maple Transactions journal after the conference.

    Registration for attending the conference will open in June. We will also be featuring an art gallery again at the conference. Watch for further announcements in the coming weeks.

    I sincerely hope that all of you here in the Maple Primes community will consider joining us for this event, whether as a presenter or attendee!

    Mapleprimes appears unfinished and is in need of some maintenance.

    If you click on the products option page there are several products missing from the sort (MapleSim, MapleFlow, MapleLearn).  Also clicking on questions gives you only a maplesim and maple option.

    Those are some of the things I would like mapleprimes to please update.

    A user found that the behaviour of calling a command from a library with a long form command name which invoked another command from that library with the short form name was unexpected:

    restart;
    ScientificConstants:-GetValue(Constant(g))

    Error, (in ScientificConstants:-GetValue) `Constant(g)` is not a scientific constant object

     

     

     

    We suggested to either

    [Edit May 13 after Acer's improvements]

    A) import the package such that all short form names of commands from the package are available in the Maple session and use the short form of both commands:

    restart;
    with(ScientificConstants):
    GetValue(Constant(g));

    9.80665

    (1)

    Download scientificConstantsGetValueShortFormsWithPackage.mw

    or

    B) use long forms for both command names:

    restart;
    ScientificConstants:-GetValue(ScientificConstants:-Constant(g))

    9.80665

    (1)

    Download scientificConstantsGetValueLongFormLongForm.mw

    or

    C) to test that a long form command and a short form command work together, import the package for the short form command:

    restart;
    with(ScientificConstants):
    ScientificConstants:-GetValue(Constant(g))

    9.80665

    (1)

    Download scientificConstantsGetValueLongFormWithPackage.mw

    Further details can be found in the article ?UsingPackages

    1 2 3 4 5 6 7 Last Page 1 of 286