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
  • The Railway Challenge is a competition designed by the Institute of Mechanical Engineers (IMechE), aimed at engaging young engineers with the rail industry.  The challenge, now in its seventh successive year, brings together teams of university students, as well as apprentices and graduates working in industry across the world to test their business knowledge, design ability and technical skills in a live test environment.

    The Railway Challenge at Sheffield (RCAS) is an extracurricular student-led activity within the Mechanical Engineering department at the university of Sheffield, that designs, codes and manufactures a 10 1/4 inch gauge miniature locomotive to compete in the IMechE’s  Railway Challenge.  The locomotive is assessed in accordance with a set of strict rules and a detailed technical specification, such as traction, ride comfort, and a business case. The locomotives are tested live at a competition, which takes place in June at the Stapleford Miniature Railway in Leicestershire, where several categories of winners and an overall Railway Challenge champion is crowned.

    The team consists of around twenty members, and students studying Mechanical Engineering and even cross discipline can get involved as soon as they come to the University, getting into to the design of components within the suspension or braking systems for example, before proceeding to manufacture and test; allowing the students to experience all the stages of an engineering product as well as skills gained by working in the team such as effective communication, time management and financial planning.

    Last year the team was granted a sponsorship from Maplesoft, and as a result, huge improvements were made within the team. Overall the team jumped from finishing in 7th place to in the summer winning the maintainability challenge and finishing in 4th place overall – mostly down to the electronics working for the first year ever!

     

    Using Maplesoft’s donation the team switched form a central CRIO control system to a distributed network using I2C protocols and Arduino hardware. This did away with some of the electrical teething problems the team has suffered in previous years. It also introduced our Mechanical Engineers to coding that they would otherwise not do in their course.

    This year Maplesoft have again sponsored RCAS. The team is hoping to use the licenses to perform their structures calculations in an easy way to keep track of them for use in the design report. They are also hoping to use MapleSim for dynamics modelling, to assist with suspension design, and designing any electronics or control elements, such as filter design and motor control.

    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!

    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


     

    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

    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

    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.

     

    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)
     

    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.

    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

    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.

    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. 

    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

    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

    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);

     

    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

     

     

     

     

    First 50 51 52 53 54 55 56 Last Page 52 of 304