Advanced Search

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
    •

    Introducing #MapleOfficeHours!

    by: RochelleAngyal 270 Maple
    October 11 2017
    5  5

    We’re so excited to bring you guys #MapleOfficeHours! This is a program we’ve designed for students (but open to everyone) to connect via social media for help with Maple. Maple can play a really important part in your courses and can sometimes be intimidating for new users. We get it, there’s a lot of ground to cover. With #MapleOfficeHours, we will use social media as a live Q&A platform to help you figure out how to use Maple for your homework, assignments and more. Having trouble with a command or function? #MapleOfficeHours. Need help finding a specific resource or app? #MapleOfficeHours. You get the idea…

    Just like the office hours your professors hold, #MapleOfficeHours is going to be available on a regular basis for support. More events will be scheduled soon, but look out for Twitter chats, mini-webinars, Facebook live events and more. Once we get going, we’d love to hear your feedback on what other types of events we can offer and what topics you’d like to see covered.

    Our first #MapleOfficeHours event will be a live Twitter chat. On October 16th at 2PM EDT, I will be joined with Maple Product Manager, @DanielSkoog and Tech Support Team Lead, Dr. Matt Calder to answer as many questions about Maple that we can possibly fit into an hour’s time.

    To join the Twitter chat, use the hashtag #MapleOfficeHours when posting your questions and/or mention us with @maplesoft.

    Looking forward to seeing everyone at our first #MapleOfficeHours event on October 16th, 2PM EDT!

    Work of a Force

    by: Lenin Araujo Castillo 1790 Maple 2017
    engineering solve syntax
    October 10 2017
    4  0

    Using the syntax in Maple we develop the energy with conservation equations here we are applying the commands int, factor, solve among others. We also integrate vector functions through the scalar product and finally we calculate conservative fields applying the rotational to a field of force. Exclusive for engineering students. In spanish.

    Work_of_a_Force.mw

    Lenin Araujo castillo

    Ambassafor of Maple

    Examples of pdsolve improvements in Maple 2017.3

    by: ecterrab 14205 Maple
    pde
    October 05 2017
    7  3


     

    Maple 2017.1 and 2017.2 introduced several improvements in the solution of PDE & Boundary conditions problems (exact solutions).  Maple 2017.3 includes more improvements in this same area.

     

    The following is a set of 25 examples of different PDE & Boundary Conditions problems that are solvable in Maple 2017.3 but not in Maple 2017.2 or previous releases. In the examples that follow, in some cases the PDE is different, in other cases the boundary conditions are of a different kind or solving the problem involves different computational strategies.

    As usual, at the end there is a link pointing to the corresponding worksheet.

     

    > 

    pde[1] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[1] := u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

    diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

    		  

    u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

    		 (1)
    > 

    `assuming`([pdsolve([pde[1], bc[1]], u(x, t))], [L > 0, k > 0])

    u(x, t) = 6+4*cos(3*Pi*x/L)*exp(-9*k*Pi^2*t/L^2)

    		 (2)
    > 

    pde[2] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[2] := g(0, x) = 1

    diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

    		  

    g(0, x) = 1

    		 (3)
    > 

    pdsolve([pde[2], bc[2]])

    g(t, x) = exp(a*t)

    		 (4)
    > 

    pde[3] := diff(u(x, t), t) = diff(u(x, t), x, x)
    > 

    bc[3] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

    diff(u(x, t), t) = diff(diff(u(x, t), x), x)

    		  

    u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

    		 (5)
    > 

    pdsolve([pde[3], bc[3]], u(x, t))

    u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

    		 (6)
    > 

    pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[4] := u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

    pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))

    		  

    u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

    		 (7)
    > 

    `assuming`([pdsolve([pde[4], bc[4]], u(x, t))], [L > 0])

    u(x, t) = Sum((2*cos((1/2)*Pi*n)+2+4*(-1)^(1+n))*sin(n*Pi*x/L)*exp(-k*Pi^2*n^2*t/L^2)/(Pi*n), n = 1 .. infinity)

    		 (8)
    > 

    pde[5] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))
    > 

    bc[5] := (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

    diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

    		  

    (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

    		 (9)
    > 

    `assuming`([pdsolve([pde[5], bc[5]], u(x, t))], [0 < L, 0 < k])

    u(x, t) = -3*cos(8*Pi*x/L)*exp(-64*k*Pi^2*t/L^2)

    		 (10)
    > 

    pde[6] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))+f(x, t); bc[6] := u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

    diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))+f(x, t)

    		  

    u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

    		 (11)
    > 

    pdsolve([pde[6], bc[6]], u(x, t))

    u(x, t) = Sum(2*(Int(g(tau1)*sin(Pi*n1*tau1/l), tau1 = 0 .. l))*sin(Pi*n1*x/l)*exp(-k*Pi^2*n1^2*t/l^2)/l, n1 = 1 .. infinity)+Int(Sum(2*(Int(f(x, tau1)*sin(Pi*n*x/l), x = 0 .. l))*sin(Pi*n*x/l)*exp(-k*Pi^2*n^2*(t-tau1)/l^2)/l, n = 1 .. infinity), tau1 = 0 .. t)

    		 (12)
    > 

    pde[7] := diff(u(x, t), t) = diff(u(x, t), x, x); bc[7] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

    diff(u(x, t), t) = diff(diff(u(x, t), x), x)

    		  

    u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

    		 (13)
    > 

    pdsolve([pde[7], bc[7]], u(x, t))

    u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

    		 (14)
    > 

    pde[8] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))-h*u(x, t); bc[8] := u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

    diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))-h*u(x, t)

    		  

    u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

    		 (15)
    > 

    pdsolve([pde[8], bc[8]], u(x, t))

    u(x, t) = sin(x)*exp(-t*(k+h))

    		 (16)
    > 

    pde[9] := diff(u(x, t), t) = diff(u(x, t), x, x)
    > 

    bc[9] := u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

    diff(u(x, t), t) = diff(diff(u(x, t), x), x)

    		  

    u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

    		 (17)
    > 

    pdsolve([pde[9], bc[9]], u(x, t))

    u(x, t) = 20+Sum((-40+100*(-1)^n)*sin(n*Pi*x)*exp(-Pi^2*n^2*t)/(Pi*n), n = 1 .. infinity)+30*x

    		 (18)
    > 

    pde[10] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[10] := u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

    		 (19)
    > 

    pdsolve([pde[10], bc[10]], u(x, y))

    u(x, y) = Sum(-4*((-1)^n-1)*sin(Pi*y*n)*(exp(Pi*n*(2*x-1))-exp(Pi*n))*exp(-Pi*n*(x-1))/((exp(2*Pi*n)-1)*Pi^3*n^3), n = 1 .. infinity)

    		 (20)
    > 

    pde[11] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0
    > 

    bc[11] := (D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    (D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

    		 (21)
    > 

    `assuming`([pdsolve([pde[11], bc[11]], u(x, y))], [0 < L, 0 < H])

    u(x, y) = Sum(2*(Int(cos(Pi*x*n/L)*f(x), x = 0 .. L))*cos(Pi*x*n/L)*exp(Pi*n*(H-y)/L)*(exp(2*Pi*y*n/L)-1)/(L*(exp(2*Pi*H*n/L)-1)), n = 1 .. infinity)

    		 (22)
    > 

    pde[12] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0
    > 

    bc[12] := (D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    (D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

    		 (23)
    > 

    `assuming`([pdsolve([pde[12], bc[12]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

    u(x, y) = Sum(-2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*(exp(-Pi*n*(L-2*x)/H)+exp(Pi*L*n/H))*exp(Pi*n*(L-x)/H)/(Pi*n*(exp(2*Pi*L*n/H)-1)), n = 1 .. infinity)

    		 (24)
    > 

    pde[13] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0
    > 

    bc[13] := (D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    (D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

    		 (25)
    > 

    `assuming`([pdsolve([pde[13], bc[13]], u(x, y))], [0 < L, 0 < H])

    u(x, y) = Sum(2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*exp(Pi*n*(L-x)/H)*(exp(2*Pi*x*n/H)+1)/(H*(exp(2*Pi*L*n/H)+1)), n = 1 .. infinity)

    		 (26)
    > 

    pde[14] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0
    > 

    bc[14] := u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

    		 (27)
    > 

    `assuming`([pdsolve([pde[14], bc[14]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

    u(x, y) = Sum(-2*(exp(-(L-2*x)*(1/2+n)*Pi/H)-exp((1/2)*Pi*(1+2*n)*L/H))*cos((1/2)*Pi*(1+2*n)*y/H)*(Int(cos((1/2)*Pi*(1+2*n)*y/H)*g(y), y = 0 .. H))*exp((1/2)*Pi*(1+2*n)*(L-x)/H)/(H*(exp(Pi*(1+2*n)*L/H)-1)), n = 0 .. infinity)

    		 (28)
    > 

    pde[15] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0
    > 

    bc[15] := u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

    		 (29)
    > 

    `assuming`([pdsolve([pde[15], bc[15]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

    u(x, y) = Sum(2*exp(Pi*n*(H-y)/L)*sin(Pi*x*n/L)*((Pi*n+L)*exp(2*Pi*y*n/L)+Pi*n-L)*(Int(sin(Pi*x*n/L)*f(x), x = 0 .. L))/(L*((Pi*n+L)*exp(2*Pi*H*n/L)+Pi*n-L)), n = 1 .. infinity)

    		 (30)
    > 

    pde[16] := diff(u(x, t), t, t) = c^2*(diff(u(x, t), x, x))
    > 

    bc[16] := u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

    diff(diff(u(x, t), t), t) = c^2*(diff(diff(u(x, t), x), x))

    		  

    u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

    		 (31)
    > 

    `assuming`([pdsolve([pde[16], bc[16]], u(x, t))], [0 < x, x <= L])

    u(x, t) = Sum(2*cos((1/2)*c*Pi*(1+2*n)*t/L)*(Int(sin((1/2)*Pi*(1+2*n)*x/L)*f(x), x = 0 .. L))*sin((1/2)*Pi*(1+2*n)*x/L)/L, n = 0 .. infinity)

    		 (32)
    > 

    pde[17] := diff(w(x1, x2, x3, t), t) = diff(w(x1, x2, x3, t), x1, x1)+diff(w(x1, x2, x3, t), x2, x2)+diff(w(x1, x2, x3, t), x3, x3)
    > 

    bc[17] := w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

    diff(w(x1, x2, x3, t), t) = diff(diff(w(x1, x2, x3, t), x1), x1)+diff(diff(w(x1, x2, x3, t), x2), x2)+diff(diff(w(x1, x2, x3, t), x3), x3)

    		  

    w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

    		 (33)
    > 

    pdsolve([pde[17], bc[17]])

    w(x1, x2, x3, t) = Sum(t^n*((proc (U) options operator, arrow; diff(diff(U, x1), x1)+diff(diff(U, x2), x2)+diff(diff(U, x3), x3) end proc)@@n)(exp(x1)+x2*x3^5)/factorial(n), n = 0 .. infinity)

    		 (34)
    > 

    pde[18] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x
    > 

    bc[18] := u(x, 0) = x

    diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x

    		  

    u(x, 0) = x

    		 (35)
    > 

    pdsolve([pde[18], bc[18]], u(x, t))

    u(x, t) = x/tan(t+(1/4)*Pi)

    		 (36)
    > 

    pde[19] := diff(u(x, t), t)-u(x, t)^2*(diff(u(x, t), x)) = 3*u(x, t)
    > 

    bc[19] := u(x, 0) = x

    diff(u(x, t), t)-u(x, t)^2*(diff(u(x, t), x)) = 3*u(x, t)

    		  

    u(x, 0) = x

    		 (37)
    > 

    pdsolve([pde[19], bc[19]], u(x, t))

    u(x, t) = -exp(3*t)*((-6*exp(6*t)*x+6*x+9)^(1/2)-3)/(exp(6*t)-1)

    		 (38)
    > 

    pde[20] := diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0
    > 

    bc[20] := u(x, 0) = x

    diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0

    		  

    u(x, 0) = x

    		 (39)
    > 

    pdsolve([pde[20], bc[20]], u(x, t))

    u(x, t) = -LambertW(-t*x)/t

    		 (40)
    > 

    pde[21] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = 0
    > 

    bc[21] := u(x, 0) = x

    diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = 0

    		  

    u(x, 0) = x

    		 (41)
    > 

    pdsolve([pde[21], bc[21]], u(x, t))

    u(x, t) = x/(t+1)

    		 (42)
    > 

    pde[22] := (t+u(x, t))*(diff(u(x, t), x))+t*(diff(u(x, t), t)) = 0; bc[22] := u(x, 1) = x

    (t+u(x, t))*(diff(u(x, t), x))+t*(diff(u(x, t), t)) = 0

    		  

    u(x, 1) = x

    		 (43)
    > 

    pdsolve([pde[22], bc[22]], u(x, t))

    u(x, t) = (t-x-1)/(ln(1/t)-1)

    		 (44)
    > 

    pde[23] := (diff(r*(diff(u(r, theta), r)), r))/r+(diff(u(r, theta), theta, theta))/r^2 = 0; bc[23] := u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

    (diff(u(r, theta), r)+r*(diff(diff(u(r, theta), r), r)))/r+(diff(diff(u(r, theta), theta), theta))/r^2 = 0

    		  

    u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

    		 (45)
    > 

    `assuming`([pdsolve([pde[23], bc[23]], u(r, theta), HINT = boundedseries)], [a > 0])

    u(r, theta) = (1/2)*(2*(Sum(r^n*(sin(n*theta)*(Int(f(theta)*sin(n*theta), theta = -Pi .. Pi))+cos(n*theta)*(Int(f(theta)*cos(n*theta), theta = -Pi .. Pi)))*a^(-n)/Pi, n = 1 .. infinity))*Pi+Int(f(theta), theta = -Pi .. Pi))/Pi

    		 (46)
    > 

    pde[24] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[24] := g(0, x) = f(x)

    diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

    		  

    g(0, x) = f(x)

    		 (47)
    > 

    pdsolve([pde[24], bc[24]])

    g(t, x) = exp(a*t)*invfourier(fourier(f(x), x, s1)*exp(-t*s1^2), s1, x)

    		 (48)
    > 

    pde[25] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[25] := u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

    diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

    		  

    u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

    		 (49)
    > 

    pdsolve([pde[25], bc[25]], u(x, y))

    u(x, y) = Sum(2*((-1)^n+1)*cos(Pi*y*n)*(exp(Pi*n*(2*x-1))-exp(Pi*n))*exp(-Pi*n*(x-1))/((exp(2*Pi*n)-1)*Pi^2*n^2), n = 1 .. infinity)

    		 (50)
    > 

    ``


     

    Download ImprovementsInPdsolve.mw

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

    Nobel prize in physics 2017 awarded for discovery...

    by: ecterrab 14205 Maple
    education
    October 03 2017
    2  4

    And the Nobel prize in physics 2017 went for work in General Relativity ! Actually, experimental work involving sophisticated detectors and Numerical Relativity, one of the branches of GR. The prize was awarded to Rainer Weiss (85 years old, 1/2 of the prize), Barry Barish (81 years old, 1/4 of the prize) and Kip Thorne (77 years old, 1/4 of the prize) who have "shaken the world again" with their work on Ligo experiment, which was able to detect ripples in the fabric of spacetime.

    General Relativity continues to be at the center of work in theoretical and experimental physics. I take this opportunity to note that, in Maple 2017, among the several improvements in the Physics package regarding General Relativity, there is a new package, Physics:-ThreePlusOne, all dedicated to the symbolic manipulations necessary to formulate problems in Numerical Relativity.

    The GR functionality implemented in Physics, Physics:-Tetrads and Physics:-ThreePlusOne is unique in computer algebra systems and reflects the Maplesoft intention, for several years now, to provide the very best possible computer algebra environment for Physics, regarding current research activity as well as related education in advanced mathematical-physics methods.

    For what is going on in theoretical physics nowadays and its connection with General Relativity, in very short: the unification of gravity with the other forces, check for instance this map from Aug/2015 (by the way a very nice summary for whoever is interested):

    It is also interesting the article behind this map of topics as well as this brilliant and accessible presentation by Nima Arkani-Hamed (Princeton):  Quantum Mechanics and Spacetime in the 21st Century, given in the Perimeter Institute for Theoretical Physics (Waterloo), November 2014. 

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

    Maple 2017.3 update

    by: eithne 2022 Maple 2017
    update
    October 03 2017
    3  2

    We have released a small maintenance update to Maple. Maple 2017.3 provides enhancements in several areas, including mathematical typesetting, pdsolve, and the Physics package. It also provides improvements to the MapleCloud, including a fix for a problem that prevented some Mac users from logging on with their Google credentials.

    This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2017.3 download page.

     

    Exercises of vectors, forces and moment

    by: Lenin Araujo Castillo 1790 Maple 2017
    engineering vector degrees
    October 03 2017
    2  0

    Group of exercises solved using Maple scientific software, with the necessary considerations of some basic commands: evalf and convert that will show the solutions with the user-defined digits and the angular measurement in sexagesimal degrees. Important use of the law of the triangle through of vector position applied to vectors in vector spaces, vector force and vector moment for engineering students. In spanish.

    Exercises_of_vectors_forces_and_moment_with_Maple.mw

    Videotutorial:

    https://www.youtube.com/watch?v=DxpO0gc5GCA

    Lenin Araujo Castillo

    Ambassador of Maple

    Riemann hypothesis is false! (simple proof)

    by: vv 13305 Maple
    October 01 2017
    2  2

    # Riemann hypothesis is false! (simple proof)
     

    restart;
    assume( s>0, s<1/2, t>0 );
    coulditbe(abs(Zeta(s+I*t))=0);
                                  true

    # Q.E.D.

    Unfortunately coulditbe(Zeta(s+I*t)=0) returns FAIL, but our assertion is already demonstrated!

    The moral: the assume facility deserves a much more careful implementation.

    Announcing MapleSim 2017

    by: eithne 2022 MapleSim
    September 28 2017
    5  2

    We’ve just released a major new version of MapleSim. The MapleSim 2017 family of products provides new and improved model development and analysis tools, expands modeling scope, introduces new deployment options, and strengthens toolchain connectivity.  Here are some highlights:

    • The new Initialization Diagnostics App further simplifies the initialization task by helping you determine how your initial values are computed and what you need to do to adjust them.
       
    • The new Modal Analysis App helps you explore and understand the natural vibration modes of your mechanism, so you can determine how to reduce the vibration in the final product. 
       
    • Over 100 new components include expansions to the Electrical and Magnetic libraries.
       
    • A new Modelica® code editor makes it easier to create Modelica-based custom components.
       
    • The MapleSim Heat Transfer Library from CYBERNET, a new add-on component library, provides a comprehensive view into heat transfer effects in your model, enabling you to refine your  design to improve performance and avoid overheating.
       
    • The new MapleSim Explorer product provides a cost-effective deployment solution that allows you to make MapleSim models available to more people in your organization.

     

    There’s more, of course.  See What’s New in MapleSim for lots more details.

    eithne

    GeneratePDF does not work for me

    by: Markiyan Hirnyk 7799 MaplePrimes
    pdf
    September 27 2017
    0  6

    Try More/GeneratePDF  in  the menu under  a post/question. See screen_26.09.17.docx as an example of a result. Also Adobe Acrobat Reader fails with it. That was submitted to MaplePrimes staff through the Contact  button at the bottom of this page. I obtained no feedback from them.

    comparison of numeric differential equation solver...

    by: itsme 769 Maple
    differential-equation numeric
    September 26 2017
    2  30

    This might be of interest to some of us here - a comparison of differential equation solvers between many different packages/tools/libraries:

    http://www.stochasticlifestyle.com/comparison-differential-equation-solver-suites-matlab-r-julia-python-c-fortran/

    The "analysis" of maple's capabilities are presented as somewhat limited in comparison to mathematica's - I wonder if this is a simple bias/misinformation of the author, or if his conclusions are correct. 

    "Almost Artistic" erroraneous maple output

    by: Adam Ledger 360 Maple
    2dmath
    September 26 2017
    0  0

    My interface has frozen, but above is a screen shot of what is by far the most unusual response from the CAS in the i guess 8 or so years ive been using it in total.

     

    *updated situation its allowing me to interrupt evaluation

    Moment of a force using vectors

    by: Lenin Araujo Castillo 1790 Maple 18
    engineering vector
    September 24 2017
    1  0

    The development of the calculation of moments using force vectors is clearly observed by taking a point and also a line. Different exercises are solved with the help of Maple syntax. We can also visualize the vector behavior in the different configurations of the position vector. Applications designed exclusively for engineering students. In Spanish.

    Moment_of_a_force_using_vectors_updated.mw

    Lenin Araujo Castillo

    Ambassador of Maple

    ClusterAnalysis applications: Finding a Minimal...

    by: Daniel Skoog 1766 Maple 2017
    cluster-analysis
    September 20 2017
    10  0

    A project that I have been working on is adding some functionality for Cluster Analysis to Maple (a small part of a much bigger project to increase Maple’s toolkit for exploratory data mining and data analysis). The launch of the MapleCloud package manager gave me a way to share my code for the project as it evolves, providing others with some useful new tools and hopefully gathering feedback (and collaborators) along the way.

    At this point, there aren’t a lot of commands in the ClusterAnalysis package, but I have already hit upon several interesting applications. For example, while working on a command for plotting clusters of points, one problem I encountered was how to draw the minimal volume enclosing ellipsoid around a group (or cluster) of points. After doing some research, I stumbled upon Khachiyan’s Algorithm, which related to solving linear programming problems with rational data. The math behind this is definitely interesting, but I’m not going to spend any time on it here. For further reading, you can explore the following:

    Khachiyan’s Algorithm had previously been applied in some other languages, but to the best of my knowledge, did not have any Maple implementations. As such, the following code is an implementation of Khachiyan’s Algorithm in 2-D, which could be extended to N-dimensional space rather easily.

    This routine accepts an Nx2 dataset and outputs either a plot of the minimum volume enclosing ellipsoid (MVEE) or a list of results as described in the details for the ‘output’ option below.

    MVEE( X :: DataSet, optional arguments, additional arguments passed to the plotting command );

    The optional arguments are as follows:

    • tolerance : realcons;  specifies the convergence criterion
    • maxiterations : posint; specifies the maximum number of iterations
    • output : {identical(data,plot),list(identical(data,plot))}; specifies the output. If output includes plot, then a plot of the enclosing ellipsoid is returned. If output includes data, then the return includes is a list containing the matrix A, which defines the ellipsoid, the center of the ellipse, and the eigenvalues and eigenvectors that can be used to find the semi-axis coordinates and the angle of rotation, alpha, for the ellipse.
    • filled : truefalse; specifies if the returned plot should be filled or not

    Code:

    #Minimum Volume Enclosing Ellipsoid
    MVEE := proc(XY, 
                  {tolerance::positive:= 1e-4}, #Convergence Criterion
                  {maxiterations::posint := 100},
                  {output::{identical(data,plot),list(identical(data,plot))} := data},
                  {filled::truefalse := false} 
                )

        local alpha, evalues, evectors, i, l_error, ldata, ldataext, M, maxvalindex, n, ncols, nrows, p1, semiaxes, stepsize, U, U1, x, X, y;
        local A, center, l_output; #Output

        if hastype(output, 'list') then
            l_output := output;
        else
            l_output := [output];
        end if;

        kernelopts(opaquemodules=false):

        ldata := Statistics:-PreProcessData(XY, 2, 'copy');

        nrows, ncols := upperbound(ldata);
        ldataext := Matrix([ldata, Vector[column](nrows, ':-fill' = 1)], 'datatype = float');

        if ncols <> 2 then
            error "expected 2 columns of data, got %1", ncols;
        end if;

        l_error := 1;

        U := Vector[column](1..nrows, 'fill' = 1/nrows);

        ##Khachiyan Algorithm##
        for n to maxiterations while l_error >= tolerance do

            X := LinearAlgebra:-Transpose(ldataext) . LinearAlgebra:-DiagonalMatrix(U) . ldataext;
            M := LinearAlgebra:-Diagonal(ldataext . LinearAlgebra:-MatrixInverse(X) . LinearAlgebra:-Transpose(ldataext));
            maxvalindex := max[index](map['evalhf', 'inplace'](abs, M));
            stepsize := (M[maxvalindex] - ncols - 1)/((ncols + 1) * (M[maxvalindex] - 1));
            U1 := (1 - stepsize) * U;
            U1[maxvalindex] := U1[maxvalindex] + stepsize;
            l_error := LinearAlgebra:-Norm(LinearAlgebra:-DiagonalMatrix(U1 - U));
            U := U1;

        end do;

        A := (1/ncols) * LinearAlgebra:-MatrixInverse(LinearAlgebra:-Transpose(ldata) . LinearAlgebra:-DiagonalMatrix(U) . ldata - (LinearAlgebra:-Transpose(ldata) . U) . LinearAlgebra:-Transpose((LinearAlgebra:-Transpose(ldata) . U)));
        center := LinearAlgebra:-Transpose(ldata) . U;
        evalues, evectors := LinearAlgebra:-Eigenvectors(A);
        evectors := evectors(.., sort[index](1 /~ (sqrt~(Re~(evalues))), `>`, ':-output' = ':-permutation'));
        semiaxes := sort(1 /~ (sqrt~(Re~(evalues))), `>`);
        alpha := arctan(Re(evectors[2,1]) / Re(evectors[1,1]));

        if l_output = [':-data'] then
            return A, center, evectors, evalues;
        elif has( l_output, ':-plot' ) then
                x := t -> center[1] + semiaxes[1] * cos(t) * cos(alpha) - semiaxes[2] * sin(t) * sin(alpha);
                y := t -> center[2] + semiaxes[1] * cos(t) * sin(alpha) + semiaxes[2] * sin(t) * cos(alpha);
                if filled then
                    p1 := plots:-display(subs(CURVES=POLYGONS, plot([x(t), y(t), t = 0..2*Pi], ':-transparency' = 0.95, _rest)));
                else
                    p1 := plot([x(t), y(t), t = 0..2*Pi], _rest);
                end if;
            return p1, `if`( has(l_output, ':-data'), op([A, center, evectors, evalues]), NULL );
        end if;

    end proc:

     

    You can run this as follows:

    M:=Matrix(10,2,rand(0..3)):

    plots:-display([MVEE(M,output=plot,filled,transparency=.3),
                    plots:-pointplot(M, symbol=solidcircle,symbolsize=15)],
    size=[0.5,"golden"]);

     

     

    As it stands, this is not an export from the “work in progress” ClusterAnalysis package – it’s actually just a local procedure used by the ClusterPlot command. However, it seemed like an interesting enough application that it deserved its own post (and potentially even some consideration for inclusion in some future more geometry-specific package). Here’s an example of how this routine is used from ClusterAnalysis:

    with(ClusterAnalysis);

    X := Import(FileTools:-JoinPath(["datasets/iris.csv"], base = datadir));

    kmeans_results := KMeans(X[[`Sepal Length`, `Sepal Width`]],
        clusters = 3, epsilon = 1.*10^(-7), initializationmethod = Forgy);

    ClusterPlot(kmeans_results, style = ellipse);

     

     

    The source code for this is stored on GitHub, here:

    https://github.com/dskoog/Maple-ClusterAnalysis/blob/master/src/MVEE.mm

    Comments and suggestions are welcomed.

     

    If you don’t have a copy of the ClusterAnalysis package, you can install it from the MapleCloud window, or by running:

    PackageTools:-Install(5629844458045440);

     

    Volume of causal diamonds in two and four dimensions...

    by: benleo12 15 Maple
    September 19 2017
    3  1

    These worksheets provide the volume calculations  of a small causal diamond near the tip of the past light cone, using dimensional analysis and particular test metrics.

    I recommend them for anyone working in causet theory on the problem of finding higher order corrections.

    2D.mw

    4D.mw

    4Dflat.mw

     

     

     

     

    Plot of Curvature in Maple

    by: Lenin Araujo Castillo 1790 Maple 2017
    curvature slider plotting
    September 19 2017
    2  0

    With this app you will be able to interpret the curvatures generated by two position vectors, either in the plane or in space. Just enter the position vectors and drag the slider to calculate the curvature at different times and you will of course be able to observe its respective graph. At first I show you how it is developed using the natural syntax of Maple and then optimize our
     app with the use of buttons. App made in Maple for engineering students. In spanish.

    Plot_of_Curvature.mw

    Videotutorial:

    https://www.youtube.com/watch?v=SbXFgr_5JDE

    Lenin Araujo Castillo

    Ambassador of Maple

    First 48 49 50 51 52 53 54 Last Page 50 of 302