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 app shows the calculation of the final speed of a body after it made contact with a variable force; Taking as reference the initial velocity, mass and graph of the variation of F as a function of time. That is, given the variable forces represented by the lines in the time intervals, we will show the equation of momentum and momentum; With their respective values, followed by their response.

    Momentum_with_two_variable_force.mw

    https://www.youtube.com/watch?v=2xWkF7JhkpI

    Lenin Araujo C.

    Ambassador of Maple

     

     

     

     

     

     

    When we first started trying to use Maple to create a maple leaf like the one in the Canada 150 logo, we couldn’t find any references online to the exact geometry, so we went back to basics. With our trusty ruler and protractor, we mapped out the geometry of the maple leaf logo by hand.

    Our first observation was that the maple leaf could be viewed as being comprised of 9 kites. You can read more about the meaning of these shapes on the Canada 150 site (where they refer to the shapes as diamonds).

    We also observed that the individual kites had slightly different scales from one another. The largest kites were numbers 3, 5 and 7; we represented their length as 1 unit of length. Also, each of the kites seemed centred at the origin, but was rotated about the y-axis at a certain angle.

    As such, we found the kites to have the following scales and rotations from the vertical axis:

    Kites:

    1, 9: 0.81 at +/- Pi/2

    2, 8: 0.77 at +/- 2*Pi/5

    3, 5, 7: 1 at +/-Pi/4, 0

    4, 6: 0.93 at +/- Pi/8

    This can be visualized as follows:

    To draw this in Maple we put together a simple procedure to draw each of the kites:

    # Make a kite shape centred at the origin.
    opts := thickness=4, color="#DC2828":
    MakeKite := proc({scale := 1, rotation := 0})
        local t, p, pts, x;

        t := 0.267*scale;
        pts := [[0, 0], [t, t], [0, scale], [-t, t], [0, 0]]:
        p := plot(pts, opts);
        if rotation<>0.0 then
            p := plottools:-rotate(p, rotation);
        end if;
        return p;
    end proc:

     

    The main idea of this procedure is that we draw a kite using a standard list of points, which are scaled and rotated. Then to generate the sequence of plots:

    shapes := MakeKite(rotation=-Pi/4),
              MakeKite(scale=0.77, rotation=-2*Pi/5),

              MakeKite(scale=0.81, rotation=-Pi/2),
              MakeKite(scale=0.93, rotation=-Pi/8),
              MakeKite(),
              MakeKite(scale=0.93, rotation=Pi/8),
              MakeKite(scale=0.81, rotation=Pi/2),
              MakeKite(scale=0.77, rotation=2*Pi/5),
              MakeKite(rotation=Pi/4),
              plot([[0,-0.5], [0,0]], opts): #Add in a section for the maple leaf stem
    plots:-display(shapes, scaling=constrained, view=[-1..1, -0.75..1.25], axes=box, size=[800,800]);

    This looked pretty similar to the original logo, however the kites 2, 4, 6, and 8 all needed to be moved behind the other kites. This proved somewhat tricky, so we just simply turned on the point probe in Maple and drew in the connected lines to form these points.

    shapes := MakeKite(rotation=-Pi/4),
              plot([[-.55,.095],[-.733,.236],[-.49,.245]],opts),

              MakeKite(scale=0.81, rotation=-Pi/2),
              plot([[-.342,.536],[-.355,.859],[-.138,.622]],opts),
              MakeKite(),
              plot([[.342,.536],[.355,.859],[.138,.622]],opts),
              MakeKite(scale=0.81, rotation=Pi/2),
              plot([[.55,.095],[.733,.236],[.49,.245]],opts),
              MakeKite(rotation=Pi/4),
              plot([[0,-0.5], [0,0]], opts):
    plots:-display(shapes, scaling=constrained, view=[-1..1, -0.75..1.25], axes=box, size=[800,800]);

    Happy Canada Day!

    With Maple, you can create amazing visualizations that go far beyond the standard mathematical plots that you might typically expect (I wince every time I see yet another sine curve).

    At your fingertips, you have

    • plotting primitives that can be assembled in new and novel ways
    • precise control over coloring (yay for ColorTools) and placement
    • an interactive coding environment with inline plots, giving you quick visual feedback over aesthetic changes
    • and a comprehensive mathematical programming language to glue everything together

    Here, I thought I'd share a few of the visualizations I've really enjoyed creating over the last few years (and I'd like to emphasize 'enjoy' - doing this stuff is fun!)

    Let me know if you want any of the worksheets.

     

    Psychrometric chart with historical weather data for Waterloo, Ontario.

     

    Ternary plot of the color of gold-silver-copper alloys

     

    Spectrogram of a violin note played with vibrato

     

    Colored zoom of the Mandelbrot set

     

    Reporting dashboard for an Organic Rankine Cycle

     

    Temperature-entropy plot of an ideal Rankine Cycle

     

    Quaternion fractal

     

    Historical sunpot data

     

    Earthquake data

     

    African literacy rates

    Do you have Maple content that you want to protect from editing and viewing, while still allowing others to execute the code within and obtain results? In Maple, worksheets can be password protected so the users of your Maple application can benefit from the specialized routines you've created while the details remain hidden.


    The password protection feature can be useful for a variety of situations, such as:

    • • Providing a Maple-based solution while protecting the intellectual property embodied in your algorithms
    • • Ensuring the users of your application can not accidentally make changes that break your code

     

    To learn more about this feature in Maple, you can download the free Tips & Techniques from the Application Center.

    We have just released an update to Maple, Maple 2017.1.  It includes improvements to the display on high resolution monitors for the debugger, MapleCloud, and help system table of contents. It also contains a variety of small improvements to the math engine, including in limit, series, Physics, typesetting, and PackageTools. This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2017.1 download page.

    eithne

    This Saturday is Canada’s 150th birthday. As you can imagine, the country has been paying a lot more attention to this year’s anniversary than our usual low key approach, and as a Canadian company, we at Maplesoft decided to join in the fun.

    And what better way for Maplesoft to celebrate Canada’s birthday than to create a maple leaf in Maple! 

    So here is a maple leaf inspired by the Canada 150 logo, which was created by Ariana Cuvin, a student at the University of Waterloo and former co-op here at Maplesoft:

    Here’s the code to reproduce this plot (more details can be found in this follow up post):

    p:=thickness=5,color="#DC2828":
    plots:-display(

        plot([[-.216,-.216],[0,0],[-.216,.216],[-.81,0],[-.216,-.216]],p),  
        plot([[-.55,.095],[-.733,.236],[-.49,.245]],p),
        plot([[-.376,0],[0,0],[0,.376],[-.705,.705],[-.376,0]],p),
        plot([[-.342,.536],[-.355,.859],[-.138,.622]],p),
        plot([[-.267,.267],[0,0],[.267,.267],[0,1],[-.267,.267]],p),
        plot([[.342,.536],[.355,.859],[.138,.622]],p),
        plot([[0.,.376],[0,0],[.376,0],[.705,.705],[0.,.376]],p),
        plot([[.55,.095],[.733,.236],[.49,.245]],p),
        plot([[.216,.216],[0,0],[.216,-.216],[.81,0],[.216,.216]],p),
        plot([[0,-.5],[0,0]],p),

    scaling=constrained,view=[-1..1,-.75..1.25],axes=box);

     

    Know other ways to plot a maple leaf in Maple?  If so, please share them below - we’d love to see them!

     

    Physics

     

     

    Maple provides a state-of-the-art environment for algebraic and tensorial computations in Physics, with emphasis on ensuring that the computational experience is as natural as possible.

     

    The theme of the Physics project for Maple 2017 has been the consolidation of the functionality introduced in previous releases, together with significant enhancements and new functionality in General Relativity, in connection with classification of solutions to Einstein's equations and tensor representations to work in an embedded 3D curved space - a new ThreePlusOne  package. This package is relevant in numerical relativity and a Hamiltonian formulation of gravity. The developments also include first steps in connection with computational representations for all the objects entering the Standard Model in particle physics.

    Classification of solutions to Einstein's equations and the Tetrads package

     

    In Maple 2016, the digitizing of the database of solutions to Einstein's equations  was finished, added to the standard Maple library, with all the metrics from "Stephani, H.; Kramer, D.; MacCallum, M.; Hoenselaers, C.; and Herlt, E., Exact Solutions to Einstein's Field Equations". These metrics can be loaded to work with them, or change them, or searched using g_  (the Physics command representing the spacetime metric that also sets the metric to your choice in one go) or using the command DifferentialGeometry:-Library:-MetricSearch .


    In Maple 2017, the Physics:-Tetrads  package has been vastly improved and extended, now including new commands like PetrovType  and SegreType  to classify these metrics, and the TransformTetrad  now has an option canonicalform to automatically derive a transformation and put the tetrad in canonical form (reorientation of the axis of the local system of references), a relevant step in resolving the equivalence between two metrics.

    Examples

     

    Petrov and Segre types, tetrads in canonical form

       

    Equivalence for Schwarzschild metric (spherical and Kruskal coordinates)

     

    Formulation of the problem (remove mixed coordinates)

       

    Solving the Equivalence

       

    The ThreePlusOne (3 + 1) new Maple 2017 Physics package

     

    ThreePlusOne , is a package to cast Einstein's equations in a 3+1 form, that is, representing spacetime as a stack of nonintersecting 3-hypersurfaces Σ. This 3+1 description is key in the Hamiltonian formulation of gravity as well as in the study of gravitational waves, black holes, neutron stars, and in general to study the evolution of physical system in general relativity by running numerical simulations as traditional initial value (Cauchy) problems. ThreePlusOne includes computational representations for the spatial metric gamma[i, j] that is induced by g[mu, nu] on the 3-dimensional hypersurfaces, and the related covariant derivative, Christoffel symbols and Ricci and Riemann tensors, the Lapse, Shift, Unit normal and Time vectors and Extrinsic curvature related to the ADM equations.

     

    The following is a list of the available commands:

     

    ADMEquations

    Christoffel3

    D3_

    ExtrinsicCurvature

    gamma3_

    Lapse

    Ricci3

    Riemann3

    Shift

    TimeVector

    UnitNormalVector

     

     

    The other four related new Physics  commands:

     

    • 

    Decompose , to decompose 4D tensorial expressions (free and/or contracted indices) into the space and time parts.

    • 

    gamma_ , representing the three-dimensional metric tensor, with which the element of spatial distance is defined as  `#mrow(msup(mi("dl"),mrow(mo("&InvisibleTimes;"),mn("2"))),mo("&equals;"),msub(mi("&gamma;",fontstyle = "normal"),mrow(mi("i"),mo("&comma;"),mi("j"))),mo("&InvisibleTimes;"),msup(mi("dx"),mi("i")),mo("&InvisibleTimes;"),msup(mi("dx"),mi("j")))`.

    • 

    Redefine , to redefine the coordinates and the spacetime metric according to changes in the signature from any of the four possible signatures(− + + +), (+ − − −), (+ + + −) and ((− + + +) to any of the other ones.

    • 

    EnergyMomentum , is a computational representation for the energy-momentum tensor entering Einstein's equations as well as their 3+1 form, the ADMEquations .

     

    Examples

     

    restart; with(Physics); Setup(coordinatesystems = cartesian)

    `Default differentiation variables for d_, D_ and dAlembertian are: `*{X = (x, y, z, t)}

     

    `Systems of spacetime Coordinates are: `*{X = (x, y, z, t)}

     

    [coordinatesystems = {X}]

    (2.1.1)

    with(ThreePlusOne)

    `Setting lowercaselatin_is letters to represent space indices `

     

    0, "%1 is not a command in the %2 package", ThreePlusOne, Physics

     

    `Changing the signature of spacetime from `(`- - - +`)*` to `(`+ + + -`)*` in order to match the signature customarily used in the ADM formalism`

     

    [ADMEquations, Christoffel3, D3_, ExtrinsicCurvature, Lapse, Ricci3, Riemann3, Shift, TimeVector, UnitNormalVector, gamma3_]

    (2.1.2)

    Note the different color for gamma[mu, nu], now a 4D tensor representing the metric of a generic 3-dimensional hypersurface induced by the 4D spacetime metric g[mu, nu]. All the ThreePlusOne tensors are displayed in black to distinguish them of the corresponding 4D or 3D tensors. The particular hypersurface gamma[mu, nu] operates is parameterized by the Lapse  alpha and the Shift  beta[mu].

    The induced metric gamma[mu, nu]is defined in terms of the UnitNormalVector  n[mu] and the 4D metric g[mu, nu] as

    gamma3_[definition]

    Physics:-ThreePlusOne:-gamma3_[mu, nu] = Physics:-ThreePlusOne:-UnitNormalVector[mu]*Physics:-ThreePlusOne:-UnitNormalVector[nu]+Physics:-g_[mu, nu]

    (2.1.3)

    where n[mu] is defined in terms of the Lapse  alpha and the derivative of a scalar function t that can be interpreted as a global time function

    UnitNormalVector[definition]

    Physics:-ThreePlusOne:-UnitNormalVector[mu] = -Physics:-ThreePlusOne:-Lapse*Physics:-D_[mu](t)

    (2.1.4)

    The TimeVector  is defined in terms of the Lapse  alpha and the Shift  beta[mu] and this vector  n[mu] as

    TimeVector[definition]

    Physics:-ThreePlusOne:-TimeVector[mu] = Physics:-ThreePlusOne:-Lapse*Physics:-ThreePlusOne:-UnitNormalVector[mu]+Physics:-ThreePlusOne:-Shift[mu]

    (2.1.5)

    The ExtrinsicCurvature  is defined in terms of the LieDerivative  of  gamma[mu, nu]

    ExtrinsicCurvature[definition]

    Physics:-ThreePlusOne:-ExtrinsicCurvature[mu, nu] = -(1/2)*Physics:-LieDerivative[Physics:-ThreePlusOne:-UnitNormalVector](Physics:-ThreePlusOne:-gamma3_[mu, nu])

    (2.1.6)

    The metric gamma[mu, nu]is also a projection tensor in that it projects 4D tensors into the 3D hypersurface Σ. The definition for any 4D tensor that is also a 3D tensor in Σ, can thus be written directly by contracting their indices with gamma[mu, nu]. In the case of Christoffel3 , Ricci3  and Riemann3,  these tensors can be defined by replacing the 4D metric g[mu, nu] by gamma[mu, nu] and the 4D Christoffel symbols GAMMA[mu, nu, alpha] by the ThreePlusOne GAMMA[mu, nu, alpha] in the definitions of the corresponding 4D tensors. So, for instance

    Christoffel3[definition]

    Physics:-ThreePlusOne:-Christoffel3[mu, nu, alpha] = (1/2)*Physics:-ThreePlusOne:-gamma3_[mu, `~beta`]*(Physics:-d_[alpha](Physics:-ThreePlusOne:-gamma3_[beta, nu], [X])+Physics:-d_[nu](Physics:-ThreePlusOne:-gamma3_[beta, alpha], [X])-Physics:-d_[beta](Physics:-ThreePlusOne:-gamma3_[nu, alpha], [X]))

    (2.1.7)

    Ricci3[definition]

    Physics:-ThreePlusOne:-Ricci3[mu, nu] = Physics:-d_[alpha](Physics:-ThreePlusOne:-Christoffel3[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Physics:-ThreePlusOne:-Christoffel3[`~alpha`, mu, alpha], [X])+Physics:-ThreePlusOne:-Christoffel3[`~beta`, mu, nu]*Physics:-ThreePlusOne:-Christoffel3[`~alpha`, beta, alpha]-Physics:-ThreePlusOne:-Christoffel3[`~beta`, mu, alpha]*Physics:-ThreePlusOne:-Christoffel3[`~alpha`, nu, beta]

    (2.1.8)

    Riemann3[definition]

    Physics:-ThreePlusOne:-Riemann3[mu, nu, alpha, beta] = Physics:-g_[mu, lambda]*(Physics:-d_[alpha](Physics:-ThreePlusOne:-Christoffel3[`~lambda`, nu, beta], [X])-Physics:-d_[beta](Physics:-ThreePlusOne:-Christoffel3[`~lambda`, nu, alpha], [X])+Physics:-ThreePlusOne:-Christoffel3[`~lambda`, upsilon, alpha]*Physics:-ThreePlusOne:-Christoffel3[`~upsilon`, nu, beta]-Physics:-ThreePlusOne:-Christoffel3[`~lambda`, upsilon, beta]*Physics:-ThreePlusOne:-Christoffel3[`~upsilon`, nu, alpha])

    (2.1.9)

    When working with the ADM formalism, the line element of an arbitrary spacetime metric can be expressed in terms of the differentials of the coordinates dx^mu, the Lapse , the Shift  and the spatial components of the 3D metric gamma3_ . From this line element one can derive the relation between the Lapse , the spatial part of the Shift , the spatial part of the gamma3_  metric and the g[0, j] components of the 4D spacetime metric.

    For this purpose, define a tensor representing the differentials of the coordinates and an alias  dt = `#msup(mi("dx"),mn("0"))`

    Define(dx[mu])

    `Defined objects with tensor properties`

     

    {Physics:-ThreePlusOne:-D3_[mu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-ThreePlusOne:-Ricci3[mu, nu], Physics:-ThreePlusOne:-Shift[mu], Physics:-d_[mu], dx[mu], Physics:-g_[mu, nu], Physics:-ThreePlusOne:-gamma3_[mu, nu], Physics:-gamma_[i, j], Physics:-ThreePlusOne:-Christoffel3[mu, nu, alpha], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-ThreePlusOne:-Riemann3[mu, nu, alpha, beta], Physics:-ThreePlusOne:-TimeVector[mu], Physics:-ThreePlusOne:-ExtrinsicCurvature[mu, nu], Physics:-ThreePlusOne:-UnitNormalVector[mu], Physics:-SpaceTimeVector[mu](X)}

    (2.1.10)

    "alias(dt = dx[~0]):"

    The expression for the line element in terms of the Lapse  and Shift   is (see [2], eq.(2.123))

    ds^2 = (-Lapse^2+Shift[i]^2)*dt^2+2*Shift[i]*dt*dx[`~i`]+gamma_[i, j]*dx[`~i`]*dx[`~j`]

    ds^2 = (-Physics:-ThreePlusOne:-Lapse^2+Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`])*dt^2+2*Physics:-ThreePlusOne:-Shift[i]*dt*dx[`~i`]+Physics:-gamma_[i, j]*dx[`~i`]*dx[`~j`]

    (2.1.11)

    Compare this expression with the 3+1 decomposition of the line element in an arbitrary system. To avoid the automatic evaluation of the metric components, work with the inert form of the metric %g_

    ds^2 = %g_[mu, nu]*dx[`~mu`]*dx[`~nu`]

    ds^2 = %g_[mu, nu]*dx[`~mu`]*dx[`~nu`]

    (2.1.12)

    Decompose(ds^2 = %g_[mu, nu]*dx[`~mu`]*dx[`~nu`])

    ds^2 = %g_[0, 0]*dt^2+%g_[0, j]*dt*dx[`~j`]+%g_[i, 0]*dt*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`]

    (2.1.13)

    The second and third terms on the right-hand side are equal

    op(2, rhs(ds^2 = dt^2*%g_[0, 0]+dt*%g_[0, j]*dx[`~j`]+dt*%g_[i, 0]*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`])) = op(3, rhs(ds^2 = dt^2*%g_[0, 0]+dt*%g_[0, j]*dx[`~j`]+dt*%g_[i, 0]*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`]))

    %g_[0, j]*dt*dx[`~j`] = %g_[i, 0]*dt*dx[`~i`]

    (2.1.14)

    subs(%g_[0, j]*dt*dx[`~j`] = %g_[i, 0]*dt*dx[`~i`], ds^2 = dt^2*%g_[0, 0]+dt*%g_[0, j]*dx[`~j`]+dt*%g_[i, 0]*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`])

    ds^2 = %g_[0, 0]*dt^2+2*%g_[i, 0]*dt*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`]

    (2.1.15)

    Taking the difference between this expression and the one in terms of the Lapse  and Shift  we get

    simplify((ds^2 = dt^2*%g_[0, 0]+2*dt*%g_[i, 0]*dx[`~i`]+%g_[i, j]*dx[`~i`]*dx[`~j`])-(ds^2 = (-Physics:-ThreePlusOne:-Lapse^2+Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`])*dt^2+2*Physics:-ThreePlusOne:-Shift[i]*dt*dx[`~i`]+Physics:-gamma_[i, j]*dx[`~i`]*dx[`~j`]))

    0 = (Physics:-ThreePlusOne:-Lapse^2-Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]+%g_[0, 0])*dt^2+2*dx[`~i`]*(%g_[i, 0]-Physics:-ThreePlusOne:-Shift[i])*dt-dx[`~i`]*dx[`~j`]*(Physics:-gamma_[i, j]-%g_[i, j])

    (2.1.16)

    Taking coefficients, we get equations for the Shift , the Lapse  and the spatial components of the metric gamma3_

    eq[1] := coeff(coeff(rhs(0 = (Physics:-ThreePlusOne:-Lapse^2-Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]+%g_[0, 0])*dt^2+2*dx[`~i`]*(%g_[i, 0]-Physics:-ThreePlusOne:-Shift[i])*dt-dx[`~i`]*dx[`~j`]*(Physics:-gamma_[i, j]-%g_[i, j])), dt), dx[`~i`]) = 0

    2*%g_[i, 0]-2*Physics:-ThreePlusOne:-Shift[i] = 0

    (2.1.17)

    eq[2] := coeff(rhs(0 = (Physics:-ThreePlusOne:-Lapse^2-Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]+%g_[0, 0])*dt^2+2*dx[`~i`]*(%g_[i, 0]-Physics:-ThreePlusOne:-Shift[i])*dt-dx[`~i`]*dx[`~j`]*(Physics:-gamma_[i, j]-%g_[i, j])), dt^2)

    Physics:-ThreePlusOne:-Lapse^2-Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]+%g_[0, 0]

    (2.1.18)

    eq[3] := coeff(coeff(rhs(0 = (Physics:-ThreePlusOne:-Lapse^2-Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]+%g_[0, 0])*dt^2+2*dx[`~i`]*(%g_[i, 0]-Physics:-ThreePlusOne:-Shift[i])*dt-dx[`~i`]*dx[`~j`]*(Physics:-gamma_[i, j]-%g_[i, j])), dx[`~i`]), dx[`~j`]) = 0

    -Physics:-gamma_[i, j]+%g_[i, j] = 0

    (2.1.19)

    Using these equations, these quantities can all be expressed in terms of the time and space components of the 4D metric g[0, 0] and g[i, j]

    isolate(eq[1], Shift[i])

    Physics:-ThreePlusOne:-Shift[i] = %g_[i, 0]

    (2.1.20)

    isolate(eq[2], Lapse^2)

    Physics:-ThreePlusOne:-Lapse^2 = Physics:-ThreePlusOne:-Shift[i]*Physics:-ThreePlusOne:-Shift[`~i`]-%g_[0, 0]

    (2.1.21)

    isolate(eq[3], gamma_[i, j])

    Physics:-gamma_[i, j] = %g_[i, j]

    (2.1.22)

    References

     
      

    [1] Landau, L.D., and Lifshitz, E.M. The Classical Theory of Fields, Course of Theoretical Physics Volume 2, fourth revised English edition. Elsevier, 1975.

      

    [2] Alcubierre, M., Introduction to 3+1 Numerical Relativity, International Series of Monographs on Physics 140, Oxford University Press, 2008.

      

    [3] Baumgarte, T.W., Shapiro, S.L., Numerical Relativity, Solving Einstein's Equations on a Computer, Cambridge University Press, 2010.

      

    [4] Gourgoulhon, E., 3+1 Formalism and Bases of Numerical Relativity, Lecture notes, 2007, https://arxiv.org/pdf/gr-qc/0703035v1.pdf.

      

    [5] Arnowitt, R., Dese, S., Misner, C.W., The Dynamics of General Relativity, Chapter 7 in Gravitation: an introduction to current research (Wiley, 1962), https://arxiv.org/pdf/gr-qc/0405109v1.pdf

      

     

    Examples: Decompose, gamma_

     

    restartwith(Physics)NULL

    Setup(mathematicalnotation = true)

    [mathematicalnotation = true]

    (2.2.1)

    Define  now an arbitrary tensor A

    Define(A)

    `Defined objects with tensor properties`

     

    {A, Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu]}

    (2.2.2)

    So A^mu is a 4D tensor with only one free index, where the position of the time-like component is the position of the different sign in the signature, that you can query about via

    Setup(signature)

    [signature = `- - - +`]

    (2.2.3)

    To perform a decomposition into space and time, set - for instance - the lowercase latin letters from i to s to represent spaceindices and

    Setup(spaceindices = lowercase_is)

    [spaceindices = lowercaselatin_is]

    (2.2.4)

    Accordingly, the 3+1 decomposition of A^mu is

    Decompose(A[`~mu`])

    Array(%id = 18446744078724512334)

    (2.2.5)

    The 3+1 decomposition of the inert representation %g_[mu,nu] of the 4D spacetime metric; use the inert representation when you do not want the actual components of the metric appearing in the output

    Decompose(%g_[mu, nu])

    Matrix(%id = 18446744078724507998)

    (2.2.6)

    Note the position of the component %g_[0, 0], related to the trailing position of the time-like component in the signature "(- - - +)".

    Compare the decomposition of the 4D inert with the decomposition of the 4D active spacetime metric

    g[]

    g[mu, nu] = (Matrix(4, 4, {(1, 1) = -1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = -1, (2, 3) = 0, (2, 4) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = -1, (3, 4) = 0, (4, 1) = 0, (4, 2) = 0, (4, 3) = 0, (4, 4) = 1}))

    (2.2.7)

    Decompose(g_[mu, nu])

    Matrix(%id = 18446744078724494270)

    (2.2.8)

    Note that in general the 3D space part of g[mu, nu] is not equal to the 3D metric gamma[i, j] whose definition includes another term (see [1] Landau & Lifshitz, eq.(84.7)).

    gamma_[definition]

    Physics:-gamma_[i, j] = -Physics:-g_[i, j]+Physics:-g_[0, i]*Physics:-g_[0, j]/Physics:-g_[0, 0]

    (2.2.9)

    The 3D space part of -g[`~mu`, `~nu`] is actually equal to the 3D metric "gamma[]^(i,j)"

    "gamma_[~,definition];"

    Physics:-gamma_[`~i`, `~j`] = -Physics:-g_[`~i`, `~j`]

    (2.2.10)

    To derive the formula  for the covariant components of the 3D metric, Decompose into 3+1 the identity

    %g_[`~alpha`, `~mu`]*%g_[mu, beta] = KroneckerDelta[`~alpha`, beta]

    %g_[`~alpha`, `~mu`]*%g_[mu, beta] = Physics:-KroneckerDelta[beta, `~alpha`]

    (2.2.11)

    To the side, for illustration purposes, these are the 3 + 1 decompositions, first excluding the repeated indices, then excluding the free indices

    Eq := Decompose(%g_[`~alpha`, `~mu`]*%g_[mu, beta] = Physics[KroneckerDelta][beta, `~alpha`], repeatedindices = false)

    Matrix(%id = 18446744078132963318)

    (2.2.12)

    Eq := Decompose(%g_[`~alpha`, `~mu`]*%g_[mu, beta] = Physics[KroneckerDelta][beta, `~alpha`], freeindices = false)

    %g_[0, beta]*%g_[`~alpha`, `~0`]+%g_[i, beta]*%g_[`~alpha`, `~i`] = Physics:-KroneckerDelta[beta, `~alpha`]

    (2.2.13)

    Compare with a full decomposition

    Eq := Decompose(%g_[`~alpha`, `~mu`]*%g_[mu, beta] = Physics[KroneckerDelta][beta, `~alpha`])

    Matrix(%id = 18446744078724489454)

    (2.2.14)

    Eq is a symmetric matrix of equations involving non-contracted occurrences of `#msup(mi("g"),mrow(mn("0"),mo("&comma;"),mn("0")))`, `#msup(mi("g"),mrow(mi("j"),mo("&comma;"),mo("0")))` and `#msup(mi("g"),mrow(mi("j"),mo("&comma;"),mi("i")))`. Isolate, in Eq[1, 2], `#msup(mi("g"),mrow(mi("j"),mo("&comma;"),mo("0")))`, that you input as %g_[~j, ~0], and substitute into Eq[1, 1]

    "isolate(Eq[1, 2], `%g_`[~j, ~0]);"

    %g_[`~j`, `~0`] = -%g_[i, 0]*%g_[`~j`, `~i`]/%g_[0, 0]

    (2.2.15)

    subs(%g_[`~j`, `~0`] = -%g_[i, 0]*%g_[`~j`, `~i`]/%g_[0, 0], Eq[1, 1])

    -%g_[0, k]*%g_[i, 0]*%g_[`~j`, `~i`]/%g_[0, 0]+%g_[i, k]*%g_[`~j`, `~i`] = Physics:-KroneckerDelta[k, `~j`]

    (2.2.16)

    Collect `#msup(mi("g"),mrow(mi("j"),mo("&comma;"),mi("i")))`, that you input as %g_[~j, ~i]

    collect(-%g_[0, k]*%g_[i, 0]*%g_[`~j`, `~i`]/%g_[0, 0]+%g_[i, k]*%g_[`~j`, `~i`] = Physics[KroneckerDelta][k, `~j`], %g_[`~j`, `~i`])

    (-%g_[0, k]*%g_[i, 0]/%g_[0, 0]+%g_[i, k])*%g_[`~j`, `~i`] = Physics:-KroneckerDelta[k, `~j`]

    (2.2.17)

    Since the right-hand side is the identity matrix and, from , `#msup(mi("g"),mrow(mi("i"),mo("&comma;"),mi("j")))` = -`#msup(mi("&gamma;",fontstyle = "normal"),mrow(mi("i"),mo("&comma;"),mi("j")))`, the expression between parenthesis, multiplied by -1, is the reciprocal of the contravariant 3D metric `#msup(mi("&gamma;",fontstyle = "normal"),mrow(mi("i"),mo("&comma;"),mi("j")))`, that is the covariant 3D metric gamma[i, j], in accordance to its definition for the signature `- - - +`

    gamma_[definition]

    Physics:-gamma_[i, j] = -Physics:-g_[i, j]+Physics:-g_[0, i]*Physics:-g_[0, j]/Physics:-g_[0, 0]

    (2.2.18)

    NULL

    References

     
      

    [1] Landau, L.D., and Lifshitz, E.M. The Classical Theory of Fields, Course of Theoretical Physics Volume 2, fourth revised English edition. Elsevier, 1975.

    Example: Redefine

       

    Tensors in Special and General Relativity

     

    A number of relevant changes happened in the tensor routines of the Physics package, towards making the routines pack more functionality both for special and general relativity, as well as working more efficiently and naturally, based on Maple's Physics users' feedback collected during 2016.

    New functionality

     
    • 

    Implement conversions to most of the tensors of general relativity (relevant in connection with functional differentiation)

    • 

    New setting in the Physics Setup  allows for specifying the cosmologicalconstant and a default tensorsimplifier


     

    Download PhysicsMaple2017.mw

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

    In this file you will be able to observe and analyze how the exercises and problems of Kinematics and Dynamics are solved using the commands and operators through a very well-structured syntax; Allowing me to save time and use it in interpretation. I hope you can share and spread to break the traditional and unnecessary myths. Only for Engineering and Science. Share if you like.

    In Spanish.

    Kinematics_using_syntax_in_Maple.mw

    Lenin Araujo Castillo

    Ambassador of Maple

    The MapleCloud now provides the GRTensorIII package for component tensor calculations in general relativity. This package is an update of the established GRTensorII package, last updated in 1999.  In early June, I had the opportunity to present this update at the recent Atlantic General Relativity meeting. The GR community was delighted to have an updated version that works well with more recent versions of Maple. Several talks specifically called out the key role GRTensorIII had in establishing the results presented.

    GRTensorIII supports the calculation of the standard curvature objects in relativity. It also provides the command which allows the definition of new tensor objects via a simple definition string (without programming). This command is the key reason for GRTensor’s continued use in the GR community. GRTensorIII also provides a new, more direct API to define a spacetime via the command. This command allows for the metric or line element definition within a worksheet – removing the need for storing the metric in a file and allowing example worksheets to be self-contained. GRTensorIII has significant new functionality to support the definition of hyper-surfaces and the calculation of junction conditions and thin-shell stress energy. An extensive series of example worksheets based on Eric Poisson’s “A Relativist’s Toolkit” are included.

    GRTensorIII is available from the MapleCloud window within Maple in the list of available packages or via a download from Maple. It can be loaded directly via the command line as: 

    It is also available on github. The source code is available on github in a separate repository: grtensor3src .  

    GRTensorIII was developed in collaboration with Kayll Lake and Denis Pollney. I would like to thank Maple for access to the beta program and Eric Poisson for testing and feedback.

    The OrthogonalExpansions package is a collection of commands to compute one-dimensional and multi-dimensional orthogonal series expansions of a function. The expansions are evaluated symbolically, numerically or in an inert form.

    In particular, the package includes six modifications of the one-dimensional Fourier series, as well the multi-dimensional Fourier, cosine and sine series, one- and multi-dimensional series expansions of classical orthogonal polynomials.


    The package includes MixedSeries command to compute multi-dimensional mixed orthogonal series expansions. Mixed series are created from the one-dimensional and multi-dimensional series that are available in the package.


    The package also includes GramSchmidtL2 command for computing symbolically or numerically an orthonormal set of one- and multi-variable functions.

     

    The Maple 2017 updates look great. I do have a question, though. Why was the user interface (palettes, toolbar icons, etc) changed from 3D to flat? Maple 2015 on Windows 7 Pro looked like a Windows  program. Maple 2017 with it's flat interface looks like it was written 30 years ago for Solaris (when the graphics in Java weren't cross platform).

    I really wish there was a way I could get 2017 to look like 2015. I know it's very minor but being a very visual person, I really like the interface graphics.
    was way beyond the competition.

    Thanks

    I've developed a framework in Maple for playing with cyclic division algebras. I have methods for multiplication and passing to and from:

    The standard basis over the base field in terms of x^i*y^j and:
    The standard matrix basis for the central simple algebra when taking coefficients in the splitting field.

    I have it done in the case of degree 7, but could generalise it to any prime degree if this is of use to anyone.

    The purpose of this post is to review how well-designed Maple 2017 GUI is for a Microsoft surface pro 4 tablet touch screen with windows 10 pro (64-bit) and to determine the performance of Maple 2017 on my tablet which has a m3 CPU with a 0.9 GHZ base frequency and 4 GB RAM.

    First, my experience is that 4 GB of RAM is far from enough. Under heavy load I have had problems before on other software with 4 GB of RAM. 68 % of my RAM and 41% of the CPU is already gone by simply running Maple and my web browser at the same time before I have even instructed Maple to do any calculations.

     

    I think a tablet with at least 8 GB of RAM would be preferred. If you only want to use Maple as an expensive calculator then you would most likely not even need 4 GB of RAM. I find that the surface pro 4 to be overpriced for the hardware it provides. I think eve windows 10 tablet http://eve-tech.com/ with up to 16 GB of RAM and with a much cheaper price looks much more promising than the Microsoft surface pro 4. When I use the surface pro 4 with word 2016 and the reference manager zotero word plugin I sometime notice a trailing line when I sweep up or down in a document with a lot of references which I suspect is because of the low amount of RAM. When I played with Maple 2017 on my surface pro I noticed the same trailing line which again indicates to me that there is not enough RAM. However, I am not certain that low RAM is the cause of such problem.  

    Secondly, I managed to increase the size of the Maple icons under the File, Edit etc. menu so now they have a perfect size for a touch screen tablet. Very cool!

     

    However, as you can see words in the text menu File, Edit etc. are way too small for a touch screen tablet. There is a lot of room to the right so the words could easily be increased in size. I am also a missing a menu item called maplet where you can attach your own maplets for easy access. It appears that Maple 2017 GUI has not been designed with a touch screen tablet in mind. I wish the words in the text menu File, Edit etc. would have increased when I increased the size of the icons. The text and icons in the sidebar are also way too small for a touch screen tablet. The name of the open tabs is also to small and x that you tap on to close the worksheet is also to small. It is almost impossible to close a worksheet because the x is so small. 

    I thinks there are ways in windows 10 to increase the text size in the menus but I have only been able to increase the text size and icon size for all software at the same time. Since, Maple is more or less the only software that I have where the menu text is too small this is not an optimal solution.   

    The table of content for Maple help files also has too small text as seen in the below picture. However, the biggest problem is not the small words it is the row spacing of the table of content. Some of the words appear almost to be on top of each other. I think the row spacing need to be increased. The text within the help files itself displays beautifully and is in the perfect size.   

     

    Another problem is that when you swipe up or down on the touch screen you dont go up or down in the maple document. You just highlight text as seen in the picture below. This needs to be fixed. Highlighting should be done by a long tap on the screen as in word 2017 on a touch screen devices.

     

     

    The norm today might be to use Maple on a desktop computer or on a laptop but I am convinced that in the future touch screen tablet will become more and more powerful making them an excellent computers to run Maple on because they are so light and portable. I think Maplesoft must have this in mind when they design the GUI.

    Now to test the performance of Maple 2017 on my tablet I decided to generate 1 000 000 random number and see how long it takes. Since I dont have a benchmark it becomes very hard to comment on how fast maple 2017 is on my tablet but I am hoping that someone can run the same code on their machine and comment on this post so we can get a benchmark.        

    time(rand()$1000000)

    Maple 2017 claims that running such code took about 50 seconds on my tablet however when I timed it with a stop watch it only took around 30 seconds hence I am a bit confused as to where the 20 seconds difference comes from?  

     

    We just posted a submission to the Maple Application Center that I thought people might be interested in. Mathematics for Chemistry isn't a typical application - it's an e-book, written in Maple by J.F. Ogilvie. It covers both standard mathematics topics chemistry students are expected to know,  such as calculus and linear algebra, as well as chemistry-specific topics like chemical equilbrium, quantum chemistry, and nuclear-magnetic-resonance spectra.

    There's lots of interesting content on the Application Center, and the range of topics is always fascinating, but it's not every day I see an entire e-book come across my desk(top)!

    If you are interested, you can find it on the Application Center, here: Mathematics for Chemistry

    eithne

    While preparing for a recent webinar, I ran across something that didn't behave the same way in Maple 2017 as it did in previous releases. In particular, it was the failure of the over-dot notation for t-derivatives to display with the over-dot. Turns out that this is due to a change in behavior of typesetting that was detailed in the What's New page for Maple 2017, a page I had looked at many times in the last few months, but apparently didn't comprehend fully. The details are below.

    Prior to Maple 2017, under the aegis of extended typesetting, the following two lines of code would alert Maple that the over-dot notation for t-derivatives should be used in the output display.

    However, this changed in Maple 2017. Extended typesetting is now the default, but these two lines of code are no longer sufficient to induce Maple to display the over-dot in output. Indeed, we would now have

    as output. The change is documented in the following paragraph

    lifted from the help page 

    Thus, it now takes the additional command

    to induce Maple to display the over-dot notation in output.

    I must confess that, even though I pored over the "What's New" pages for Maple 2017, I completely missed the import of this change to typesetting. I stumbled over the issue while preparing for an upcoming webinar, and frantically sent out help calls to the developers back in the building. Fortunately, I was quickly set straight on the matter, but was disappointed in my own reading of all the implications of the typesetting changes in Maple 2017. So perhaps this note will alert other users to the changes, and to the help page wherein one finds those essential bits of information needed to complete the tasks we set for ourselves.

    And one more thing - I was cautioned that the "= true" was essential. Without it, the command would act as a query, echoing the present state of the setting, and not making the desired change to the setting.
     

    First 45 46 47 48 49 50 51 Last Page 47 of 296