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
  • 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

    Have you ever wanted to create practice problems and quizzes that use buttons and other features to support a student making their way to an answer, such as the following?

    Let’s take a look at how you can use Maple 2022 to create documents like these that can be deployed in Maple Learn. I know I’ve always wanted to learn, so let’s learn together. All examples have a document that you can use to follow along, found here, in Maple Cloud.  

    The most important command you’ll want to take a look at is ShareCanvas. This command generates a Maple Learn document. Make sure to remember that command, instead of ShowCanvas, so that the end result gives you a link to a document instead of showing the results in Maple. You’ll also want to make sure you load the DocumentTools:-Canvas subpackage using with(DocumentTools:- Canvas).

    If you take a look at our first example, below, the code may seem intimidating. However, let’s break it down, I promise it makes sense!

    with(DocumentTools:-Canvas);
    cv := NewCanvas([Text("Volume of Revolution", fontsize = 24), "This solid of revolution is created by rotating", f(x) = cos(x) + 1, Text("about the y=0 axis on the interval %1", 0 <= x and x <= 4*Pi), Plot3D("Student:-Calculus1:-VolumeOfRevolution(cos(x) + 1, x = 0 .. 4*Pi, output = plot, caption=``)")]);
    ShareCanvas(cv);
    

    The key command is Plot3D. This plots the desired graph and places it into a Maple Learn document. The code around it places text and a math group containing the equation being graphed. 


    Let’s take a look at IntPractice now. The next example allows a student to practice evaluating an integral.

    with(Grading):
    IntPractice(Int(x*sin(x), x, 'output'='link'));
    

     This command allows you to enter an integral and the variable of integration, and then evaluates each step a student enters on their way to finding a result. The feedback given on every line is incredibly useful. Not only will it tell you if your steps are right, but will let you know if your last line is correct, i.e if the answer is correct.

    Finally, let’s talk about SolvePractice.

    with(Grading):
    SolvePractice(2*x + 3 = 6*x - 9, 'output' = 'link');
    

    This command takes an equation, and evaluates it for the specified variable. Like the IntPractice command, this command will check your steps and provide feedback. The image below shows how this command looks in Maple 2022.

    These commands are the stepping stones for creating practice questions in Maple Learn. We can do so much more in Maple 2022 scripting than I realized, so let’s continue to learn together!

    Some other examples of scripted documents in the Maple Learn Document Gallery are our steps documents, this document on the Four Color Visualization Theorem, and a color by numbers. As you can see, there’s a lot that can be done with Maple Scripting.

     Let us know in the comments if you’d like to see more on Maple 2022 scripting and Maple Learn.

    MapleSim is a fantastic tool to model multi-domain physical systems at a level that was unthinkable not so long ago. This post is about a simple problem that can be solved by hand, but where I failed with MapleSim using online resources.

    For some time, I have been looking for answers to two questions:

    • How to control which variables (and parameters) are included in MapleSims equation exports? This question is crucial to derive forward and inverse kinematics.
    • Can the Equation Extraction App (in principle) provide a similar set of equations than the Multibody Analysis App? This question is rather academic until multidomain exports are desired (which the Multibody Analysis can’t provide).

    The attached model helped me to clarify a few things and discover a real hidden secret (at least it was for me). I hope it can help others.

    The model is a rather simple 3DOF mechanism. The task was to get a set of equations to derive the two rotations and the one displacement of the mechanism as a function of x,y,z coordinates.

    After watching videos and inspecting models from the model gallery on inverse kinematics, I placed motion drivers for the input variables, added sensors for the output variables and wrapped the mechanism into a subsystem. However, as explained in more detail in the attachment, the set of exported variables was incomplete in both apps (AEs exports in the Equation Extraction Export and Position Constraints in the Multibody Analysis Export). Furthermore, the number of extracted equations did not match the three degrees of freedom.

    After numerous trials it turned out that in addition to the motion drivers and sensors, initial conditions (ICs) had to be set. This is the hidden secret.  The crucial initial conditions (detailed in the attachment) are not required to assemble and run the model. So, introducing them temporarily for equation extraction is not obvious and never came to my mind. Setting ICs is, if I am not completely mistaken, also not highlighted in the documentation. This little trick of additionally setting initial conditions answered the above questions positively (at least for this 3DOF mechanism). In fact, it worked so well that all other failed attempts of conditioning the model for equations extraction worked immediately:

    • Immobilizing the assembly with a Fixed Frame (using parameters for the fixed frame position to represent input variables; the fixed frame can be inside or outside the subsystem model).
    • Using one Prescribed Translation component Instead of 3 motion drivers
    • Using variables to pass motion signals into the model subsystem instead of using signals and ports (using From variable and To Variable components)

    These attempts underline the effort and the time spend to get the relevant equations for that simple problem. As it turned out, all approaches work but are not even required for the mechanism. The key to success was setting the ICs of the joints.  One can even strip the model down to its skeleton (removing all motion drivers and sensors as in the screen shot bellow) and still get the desired simple set of equations, provided the ICs are set.

     

    It has to be noted, that the mechanically coupled (highlighted in yellow) prismatic joints contributed to the problems: MapleSim does not seem to take this mechanical constraint into account (as I would have expected). The ICs of both coupled components must be set to get the three equations containing all desired in and output variables.

    If my finding is correct and of general relevance, I like to suggest including such kind of tips and tricks in training or reference material.  From an application engineer or developers’ perspective, knowing the underlying algorithms, its probably obvious what has to be done. But from a user’s perspective MaplsSim is a black box that works magically well in most cases. If it does not, trial and error is often the only alternative to make it work, because models are either too complex or too confidential to be shared with others.   

    What I am addressing here is only the initial step of getting the desired equations. There is more to master. Save manipulation of equations too big to be inspected visually is also important. This has been well covered in several videos. Unfortunately, the quality of some of the footage does not allow to capture details of Maple commands. If possible, such material should be updated or replaced.

    Overall, a collection of tips&tricks and dos&don’ts could establish some kind of best practice in deriving kinematics. If others would share their experience and findings, we all could save allot of time. A collection of valuable posts, questions, models, videos, and webinars could be a start. This collection not necessarily has to meet the high Maple standards of mathematical exactness and consistency. Engineers also accept pragmatic solutions to solve a problem.

    If my findings are incorrect or you have better advise, please let us know.

    MBA_and_equation_extraction.msim

    We’ve just released Maple Flow 2022!

    The name of the product – Flow - references a psychological concept known as the flow state. You might know it as being in the zone. That’s when you’re so immersed in your present task that outside distractions melt away, your problem solving skills are firing on all four cylinders, and feel-good neurochemicals flood your brain.

    Maple Flow supports a mathematical flow state through a simple design that productively guides the loosely structured and somewhat haphazard way that most people work.

    Since Maple Flow's release a year ago, we've regularly added new features through updates, and we're commited to maintaining that momentum. These updates are driven by user feedback, so keep sending your comments and requests my way.

    Here’s what we have lined up for you in Flow 2022.

    Flow 2022 features a new in-product help system - see it in action here:

    In addition to copying & pasting equations and expressions from a help page, you can open entire help pages as worksheets. The nature of Flow means that the help pages have a certain immediacy that becomes very tangible once you start working with them.

    You can change the background colour of containers to highlight important results or draw the reader's attention to specific groups of containers.

    Prior versions of Flow were a toolbox that needed to be installed on top of Maple.

    Now, Flow 2022 is completely standalone, and does not require an existing installation of Maple.This makes managing an installation of Flow far simpler.

    A new options menu let you specify how you want worksheet hyperlinks to open – in the same application window, or in a new application window.

    We've also made many other quality-of-life changes to Flow. Head on over to the Maple Flow website to learn more or download an evaluation.

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