A new collection has been released on Maple Learn! The new Pascal’s Triangle Collection allows students of all levels to explore this simple, yet widely applicable array.

Though the binomial coefficient triangle is often referred to as Pascal’s Triangle after the 17th-century mathematician Blaise Pascal, the first drawings of the triangle are much older. This makes assigning credit for the creation of the triangle to a single mathematician all but impossible.

Persian mathematicians like Al-Karaji were familiar with the triangular array as early as the 10th century. In the 11th century, Omar Khayyam studied the triangle and popularised its use throughout the Arab world, which is why it is known as “Khayyam’s Triangle” in the region. Meanwhile in China, mathematician Jia Xian drew the triangle to 9 rows, using rod numerals. Two centuries later, in the 13th century, Yang Hui introduced the triangle to greater Chinese society as “Yang Hui’s Triangle”. In Europe, various mathematicians published representations of the triangle between the 13th and 16th centuries, one of which being Niccolo Fontana Tartaglia, who propagated the triangle in Italy, where it is known as “Tartaglia’s Triangle”. 

Blaise Pascal had no association with the triangle until years after his 1662 death, when his book, Treatise on Arithmetical Triangle, which compiled various results about the triangle, was published. In fact, the triangle was not named after Pascal until several decades later, when it was dubbed so by Pierre Remond de Montmort in 1703.

The Maple Learn collection provides opportunities for students to discover the construction, properties, and applications of Pascal’s Triangle. Furthermore, students can use the triangle to detect patterns and deduce identities like Pascal’s Rule and The Binomial Symmetry Rule. For example, did you know that colour-coding the even and odd numbers in Pascal’s Triangle reveals an approximation of Sierpinski’s Fractal Triangle?

See Pascal’s Triangle and Fractals

Or that taking the sum of the diagonals in Pascal's Triangle produces the Fibonacci Sequence?

See Pascal’s Triangle and the Fibonacci Sequence

Learn more about these properties and discover others with the Pascal’s Triangle Collection on Maple Learn. Once you are confident in your knowledge of Pascal’s Triangle, test your skills with the interactive Pascal’s Triangle Activity. 

On November 11^th, Canada and other Commonwealth member states will celebrate Remembrance Day, also known as Armistice Day. This holiday commemorates the armistice signed by Germany and the Entente Powers in Compiègne, France on November 11, 1918, to end the hostilities on the Western Front of World War I. The armistice came into effect at 11:00 am that morning – the “eleventh hour of the eleventh day of the eleventh month”. 

Similar to how November 11^th – which can be written as 11/11 – is a palindromic date that reads the same forward and backward, last year there was “Twosday” – February 22, 2022, also written 22/2/22. 

Palindromic dates like November 11^th that consist only of a day and a month happen every year, but how long will we have to wait until the next “Twosday”? We can use Maple Learn’s new Calendar Calculator to find out!

To use this document, simply input two dates and press ‘Calculate’ to find the amount of time between them, presented in a variety of units. For example, here are the results for the number of days left until Christmas from November 11^th of this year:

If we return to our original question, which concerns how long we’ll have to wait until the next “Twosday”, we can use this document to find our answer:

You can use this document as a countdown to find out how much time is left until your favorite holiday, your next birthday, or the time between now and any past or future date; try out the countdown document here!

My idea has been written down here, check out

Equivalence_class_of_solvable_Abel_and_Riccati_equation_(2).pdf

[moderator: updated with new approach, as follows, Feb 5, 2024]

Equivalence_rational_transformation_of_Riccati_equation_05022024.pdf
We have found new way to find equivalence transformation that yields a rational differential equation to Riccati equation, therefore computing non-Liouvillian first integral will be possible. This method can be implemented by Maple.

This is an successfull attempt to simulate space frames in MapleSim using the relatively new Rod component.

At t=3s, a lateral force component is applied to make the simulation more interesting.

The structure collapses/folds in an origami style fashion.

To build the model, MapleSim needs additional components.

For example, an equilateral triangle

requires the addition of rigid body frames at the connection of two rods.

Additionally, the rigid body frames must have initial position conditions (ICs) that match the intended structure.

Interestingly the ICs do not have to be set to Treat as Guess. It is only required to put an approximate coordinate. Leaving the ICs on Ignore was sufficient for the attached model.

Rod components can be replaced by Flexible Beam components which require considerably more simulation time and either Revolute joints at their ends or a rather complex connection with Rigid Body frames (of zero length) to adjacent Flexible Beam components.

Spaceframe_2.msim

Almost 300 years ago, a single letter exchanged between two brilliant minds gave rise to one of the most enduring mysteries in the world of number theory. 

In 1742, Christian Goldbach penned a letter to fellow mathematician Leonhard Euler proposing that every even integer greater than 2 can be written as a sum of two prime numbers. This statement is now known as Goldbach’s Conjecture (it is considered a conjecture, and not a theorem because it is unproven). While neither of these esteemed mathematicians could furnish a formal proof, they shared a conviction that this conjecture held the promise of being a "completely certain theorem." The following image demonstrates how prime numbers add to all even numbers up to 50:

From its inception, Goldbach's Conjecture has enticed generations of mathematicians to seek evidence of its legitimacy. Though weaker versions of the conjecture have been proved, the definitive proof of the original conjecture has remained elusive. There was even once a one-million dollar cash prize set to be awarded to anyone who could provide a valid proof, though the offer has now elapsed. While a heuristic argument, which relies on the probability distribution of prime numbers, offers insight into the conjecture's likelihood of validity, it falls short of providing an ironclad guarantee of its truth.

The advent of modern computing has emerged as a beacon of progress. With vast computational power at their disposal, contemporary mathematicians like Dr. Tomàs Oliveira e Silva have achieved a remarkable feat—verification of the conjecture for every even number up to an astonishing 4 quintillion, a number with 18 zeroes.

Lazar Paroski’s Goldbach Conjecture Document on Maple Learn offers an avenue for users of all skill levels to delve into one of the oldest open problems in the world of math. By simply opening this document and inputting an even number, a Maple algorithm will swiftly reveal Goldbach’s partition (the pair of primes that add to your number), or if you’re lucky it could reveal that you have found a number that disproves the conjecture once and for all.

# ----------------------------------THE DESIGN OF THE MAPLET SCREEN---------------------
with(Maplets[Elements]):
HCC:=Maplet(Window('title'="HEAT CONDUCTIVITY CONTROL",["WITH THIS APPLICATION THE CONDUCTIVITY COEFFICIENT OF A ONE-DIMENSIONAL OBJECT, APPROXIMATING THE TEMPRATURE OF THE OBJECT TO A TARGET TEMPRETURE AT A CERTAIN FINAL TIME, IS CONTROLLED. ",[["l",TextField[l](3)],["T",TextField[T](3)],["f(x,t)",TextField[f](15)],["phi(x)",TextField[ph](5)]],[["k(0)",TextField[k0](3)],["g0(t)",TextField[g0](10)],["k(l)",TextField[kl](3)],["g1(t)",TextField[g1](10)],["mu(x)",TextField[mu](10)]],[["alpha",TextField[alpha](3)],["kaplus(x)",TextField[kaplus](5)],["N",TextField[N](3)],["kstart(x)",TextField[kstart](3)],["beta",TextField[beta](3)],["eps",TextField[eps](3)]] ,[Button("Calculate the Control",Evaluate('kutu'=ms(N,l,alpha,T,ph,f,g0,g1,mu,kaplus,k0,kl,kstart,beta,eps))),[TextBox['kutu'](30..30)],Button("Draw the Control",Evaluate('Draw'='plot(kutu,x=0..l)')),Plotter['Draw'](),[[Button("Distance to
Target",Evaluate('kutu2'=ms8(N,l,alpha,T,ph,f,g0,g1,mu,kaplus,k0,kl,kstart,beta,eps))),TextField['kutu2'](12)],[Button("Approximation to kaplus",Evaluate('kutu3'='evalf(int((kutu-kaplus)^2,x=0..l))')),TextField['kutu3'](12)]]],Button("Shutdown",Shutdown())])):
# -------------------------PROCEDURE FOR CALCULATION OF THE CONTROL FUNCTION-----------
with(inttrans):
with(linalg):
ms:=proc(N,l,alpha,T,ph,f,g0,g1,mu,kaplus,k0,kl,kstart,beta,eps):
with(inttrans):
with(linalg):
w:=simplify(x^2/2*g1/(l*kl)+(x^2/2-x*l)*g0/(l*k0)):
phdal:=ph-subs(t=0,w):
fdal:=simplify(f-diff(w,t)+diff(kaplus*diff(w,x),x)):
# ---------------------------------Solution of the Heat Problem------------------------------------
dp:=proc(ka)
with(inttrans):
with(linalg):
phi:=Vector(1..N):
phi[1]:=1/sqrt(l):
for i from 2 to N do
phi[i]:=evalf(sqrt(2/l)*cos((i-1)*Pi*x/l)):
od:
K:=Array(1..N,1..N):
for j from 1 to N do
for k from 1 to N do
K[j,k]:=evalf(-int(ka*diff(phi[k],x$2)*phi[j],x=0..l)):
od:
od:
F:=Vector(1..N):
for n from 1 to N do
F[n]:=evalf(int(fdal*phi[n],x=0..l)):
od:
A:=Vector(1..N):
for m from 1 to N do
A[m]:=evalf(int(phdal*phi[m],x=0..l)):
od:
KL:=Matrix(1..N,1..N):
for j1 from 1 to N do
for k1 from 1 to N do
if (j1=k1) then KL[j1,k1]:=s+K[j1,k1] else KL[j1,k1]:=K[j1,k1] fi:
od:
od:
FL:=Vector(1..N):
for i1 from 1 to N do
FL[i1]:=evalf(laplace(F[i1],t,s));
od:
S:=Vector(1..N):
for i2 from 1 to N do
S[i2]:=(A[i2]+FL[i2]);
od:
C:=Vector(1..N):
C:=evalm(inverse(KL)&*S):
c:=Vector(1..N):
for i3 from 1 to N do
c[i3]:=evalf(invlaplace(C[i3],s,t)):
od:
v:=evalf(add(c[n1]*phi[n1],n1=1..N)):
uyak:=v+w;
end:
# ---------------------------------Solution of the Adjoint Problem------------------------------------
ap:=proc(ka)
with(inttrans):
with(linalg):
utau:=evalf(subs(t=T-tau,dp(ka))):
phe:=evalf(2*(subs(tau=0,utau)-mu));
phie:=Vector(1..N):
phie[1]:=1/sqrt(l):
for i4 from 2 to N do
phie[i4]:=evalf(sqrt(2/l)*cos((i4-1)*Pi*x/l)):
od:
Kc:=Array(1..N,1..N):
for j2 from 1 to N do
for k2 from 1 to N do
Kc[j2,k2]:=evalf(-int(ka*diff(phie[k2],x$2)*phie[j2],x=0..l)):
od:
od:
Fc:=Vector(1..N):
for m1 from 1 to N do
Fc[m1]:=0:
od:
Ac:=Vector(1..N):
for cm1 from 1 to N do
Ac[cm1]:=evalf(int(phe*phie[cm1],x=0..l)):
od:
KLC:=Matrix(1..N,1..N):
for cj1 from 1 to N do
for ck1 from 1 to N do
if (cj1=ck1) then KLC[cj1,ck1]:=s+Kc[cj1,ck1] else KLC[cj1,ck1]:=Kc[cj1,ck1] fi:
od:
od:
FLC:=Vector(1..N):
for ci1 from 1 to N do
FLC[ci1]:=evalf(laplace(Fc[ci1],tau,s));
od:
Sc:=Vector(1..N):
for ci2 from 1 to N do
Sc[ci2]:=(Ac[ci2]+FLC[ci2]);
od:
CC:=Vector(1..N):
CC:=evalm(inverse(KLC)&*Sc):
cc:=Vector(1..N):
for ci3 from 1 to N do
cc[ci3]:=evalf((invlaplace(CC[ci3],s,tau))):
od:
ve:=evalf(add(cc[cn]*phie[cn],cn=1..N)):
eta:=evalf(subs(tau=T-t,ve));
end:
# ---------------------------------Calculation of the Gradient----------------------------------
T�rev:=proc(alpha,ka)
T�re:=simplify(evalf(-int(diff(dp(ka),x)*diff(ap(ka),x),t=0..T)+2*alpha*(ka-kaplus)));
end:
# ----------------------------Calculation of the Cost Functional--------------------------------
Jka:=proc(ka)
IJ1:=evalf(int((subs(t=T,dp(ka))-mu)^2,x=0..l));
end:
Sta:=proc(ka)
IJ2:=simplify(evalf((int((ka-kaplus)^2,x=0..l))));
end:
II:=proc(ka)
IJ:=simplify(evalf(Jka(ka)+alpha*Sta(ka))):
end:# 
# -----------------------------------Minimizing Process--------------------------------------------
a[0]:=kstart:
ka[0]:=kstart:
say�:=0:
for im from 0 to 60 do
a[im+1]:=simplify(evalf(ka[im-say�]-beta*T�rev(alpha,ka[im-say�]))): 
fark:=evalf(II(ka[im-say�])-II(a[im+1])): 
if(fark>0 and fark<eps) then break elif (fark>0) then 
j:=im+1: ka[j-say�]:=a[im+1]:   elif(fark<=0) then  say�:=say�+1: beta:=beta/(1.2): ka[im-say�+2]:=ka[im-say�+1]:   else fi:
od:
optcont:=a[im+1]:
end:
# -------------------------END OF THE PROCEDURE FOR CALCULATION OF THE CONTROL FUNCTION-----------
# ------PROCEDURE FOR CALCULATION OF THE DISTANCE TO THE TARGET FUNCTION-----------
ms8:=proc(N,l,alpha,T,ph,f,g0,g1,mu,kaplus,k0,kl,kstart,beta,eps):
with(inttrans):
with(linalg):
w8:=simplify(x^2/2*g1/(l*kl)+(x^2/2-x*l)*g0/(l*k0)):
phdal8:=ph-subs(t=0,w8):
fdal8:=simplify(f-diff(w8,t)+diff(kaplus*diff(w8,x),x)):
phi8:=Vector(1..N):
phi8[1]:=1/sqrt(l):
for i8 from 2 to N do
phi8[i8]:=evalf(sqrt(2/l)*cos((i8-1)*Pi*x/l)):
od:
K8:=Array(1..N,1..N):
for j8 from 1 to N do
for k8 from 1 to N do
K8[j8,k8]:=evalf(-int(ms(N,l,alpha,T,ph,f,g0,g1,mu,kaplus,k0,kl,kstart,beta,eps)*diff(phi8[k8],x$2)*phi8[j8],x=0..l)):
od:
od:
F8:=Vector(1..N):
for m28 from 1 to N do
F8[m28]:=evalf(int(fdal8*phi8[m28],x=0..l)):
od:
A8:=Vector(1..N):
for m8 from 1 to N do
A8[m8]:=evalf(int(phdal8*phi8[m8],x=0..l)):
od:
KL8:=Matrix(1..N,1..N):
for j18 from 1 to N do
for k18 from 1 to N do
if (j18=k18) then KL8[j18,k18]:=s+K8[j18,k18] else KL8[j18,k18]:=K8[j18,k18] fi:
od:
od:
FL8:=Vector(1..N):
for i148 from 1 to N do
FL8[i148]:=evalf(laplace(F8[i148],t,s));
od:
S8:=Vector(1..N):
for i48 from 1 to N do
S8[i48]:=(A8[i48]+FL8[i48]);
od:
C8:=Vector(1..N):
C8:=evalm(inverse(KL8)&*S8):
c8:=Vector(1..N):
for i58 from 1 to N do
c8[i58]:=evalf(invlaplace(C8[i58],s,t)):
od:
v8:=evalf(add(c8[n8]*phi8[n8],n8=1..N)):
uyak8:=v8+w8;
IJ18:=evalf(int((subs(t=T,uyak8)-mu)^2,x=0..l));
end:
# ------END OF THE PROCEDURE FOR CALCULATION OF THE DISTANCE TO THE TARGET FUNCTION-----------
Maplets[Display](HCC):

Here's a few commands you can use within Maple to collect information about your computer.  This is on a Windows 7 machine but should work for most Win7+ systems.  Not sure how far back the WMIC commands can be used, and it won't work on Mac or Linux. 

Download Maple_-_computer-info.mw

This post is in response to a question regarding the speed of Maple 2023 on different computers. 

I'm asking users to suggest a few benchmark problems for Maple to calculate for testing.  Basic system information (Processor speed, RAM, video card etc..) perform the calculation, get the timing and then we can collect all the information into a chart where we can update it in the original post of this thread. 

All input is welcome, it doesn't have to be confined to Maple 2023.  We can expand to as many older versions as we wish. 

we have recieved lots of great sumissions, but we want your great submission and now you have more time.

The deadline for submissions to the Art Gallery and Showcase for the 2023 Maple Conference is rapidly approaching. We really want to see your art! It doesn't have to be incredibly impressive or sophisticated, we just want to see what our community can create! If you've been working on something or have a great idea, you still have a few days to get it together to submit.

Submission can be made by email to gallery@maplesoft.com but be sure to visit the visit our Call for Creative Works for details on the format of the submission.

The Proceedings of the Maple Conference 2022 are up at mapletransactions.org and I hope that you will find the articles interesting.  There is a brief memorial to Eugenio Roanes-Lozano, whom some of you will remember from past meetings. 

The cover image was the "People's Choice" from the Art Gallery, by Paul DeMarco.

This provides a nice excuse to remind you to register at the conference page for the Maple Conference 2023 and in particular to remind you to submit your entries for the Art Gallery.  See you there!  The conference will take place October 26 and 27, and features plenary talks by our own Laurent Bernardin and by Tom Crawford (Oxford, but more widely known as "The Naked Mathematician" for his incredibly popular YouTube videos on mathematical topics). See Tom Rocks Maths for more (or less :)

The deadline for submission to the Proceedings (which will again be published in Maple Transactions) will be Nov 27, one month after the conference ends.  We have put new processes in place to ensure a more timely publication schedule, and we anticipate that the Proceedings will be published in early Spring 2024.

Advanced Engineering Mathematics with Maple (AEM) by Dr. Lopez is such an art.

Mathematics and Control Theory talks easily in Maple...

Thanks Prof. Lopez. You are the MAN !!

Dr. Ali GÜZEL

The concept of “Maple Learn art” debuted on the MaplePrimes blog in December 2021.  Since then, we’ve come a long way with new Maple Learn features and ever-growing creative minds.  Creating art using mathematical expressions and shapes is a great way to hone both your mathematical skills and your creativity, and is the perfect break from a bout of studying or the like.

I started my own Maple Learn art journey over one year ago.  Let’s see how one’s art can improve over time using new and advanced features!

Art with Shapes, March 2022

This pi-themed pie is simple and cute, but could use some additional features:

Adding Shaded() around Maple Learn shape commands colors them in!

Fun fact: I hand-picked all of the coordinates for that pi symbol.  It was an arduous but rewarding process.  Nowadays, I recommend a new method.  When you create a table in Maple Learn with two number columns, the values are plotted as points.  These points can be clicked and dragged across the plot window, and the table updates automatically to display the new coordinates.  How can you use this to make art?

1. Create a table as described above.
2. Move the points with your mouse to create an outline of the desired shape.
3. Use the coordinates from your table in your geometry command.

Let’s apply these techniques in a newer piece: a full recreation of the spaghetti emoji!

Art with Shapes, August 2023

Would you look at that?!  Fully-shaded colors, a background, and lines of spaghetti noodles that weren’t painstakingly guesstimated combine to create a wonderfully improved piece of art.

Art with Animation, March 2022

Visit the document to see its animation.  Animation is an invaluable feature in Maple Learn, frequently utilized to observe how changing variables affect functions or model a concept.  We’ve harnessed its power for animated artwork!  This animation is cute, using parametric functions and more to change the image as the animation variable changes.  Like the previous piece, it’s missing a background, and the leaves overlap the stem awkwardly in some places.

Art with Animation, August 2023

This piece has a simple background made with a large black square, but it enhances the overall effect.

The animation here comes from piecewise functions, which display different values based on a given criterion.  In this case, the criterion is the current value of the animation variable.

There are 32 individual polygons in this image (including 8 really tiny ones along the edges!) and 8 rainbow colors.  Each color is associated with a different piecewise function, and displays four random squares in that color in each frame of the animation.

This image isn’t that much more advanced than the animated flower, but I think the execution has vastly improved.

Whether you’ve been following these blog posts since December 2021 or are new to Maple Learn, we hope you give Maple Learn art a try.

And don’t forget that Maple is also a goldmine of artistic potential.  Maple’s bountiful collection of packages such as Fractals, ColorTools, plottools and more are great places to start for math that is as aesthetically pleasing as it is informative.

This week, our staff participated in a series of art challenges using either Maple Learn or Maple itself, each featuring a suggested theme and suggested mathematical content.  Check out the challenges and some of our employees’ entries below, and try out a challenge for yourself!

Tuesday’s Art Theme: Pasta

Mathematical Content: Shapes

Example: Lazar Paroski’s spiraling take on spaghetti

Wednesday’s Art Theme: Nature

Mathematical Content: Fractals

Example: John May’s Penrose tiling landscape (in Maple!)

Thursday’s Art Theme: Disco

Mathematical Content: Animation

Example: Paulina Chin’s disco ball (in Maple!)

Friday’s Art Theme: Space

Mathematical Content: Color

Example: that’s today!  Who knows what our staff will create…?

We hope these prompts have inspired you! If you create some art you’re really proud of, consider submitting it to be featured in the 2023 Maple Conference’s Creative Works Showcase.

Space. The final frontier. A frontier we wouldn’t stand a chance of exploring if it weren’t for the work of one Albert Einstein and his theories of special relativity. After all, how are we supposed to determine at what speed an alien spaceship is traveling towards Earth if we can’t understand how Newtonian physics break down at high velocities? That is precisely the question that this Maple MathApp asks. Using the interactive tool, you can see how the relative velocities change depending on your reference point. Just what you need for the next time you see a UFO rocketing through the sky!

But what if you don’t have the MathApp on hand when the aliens visit? (So rare to travel anywhere without a copy of Maple on you, I know, but it could happen.) You’ll have to just learn more about special relativity so that you can make those calculations on the fly. And luckily, we have just what you need to do that: our new Maple Learn collection on modern physics, created by Lazar Paroski. Still not quite sure how to wrap your head around the whole thing? Check out this document on the postulates of special relativity, which explains and demonstrates some of the fundamentals of special relativity with lively animations.

Once you’ve gotten familiar with the basics, it’s time to get funky. This document on time dilation shows how two observers looking at the same event from different frames of reference can measure different times for that event. And of course once you start messing with time, everything gets weird. For an example, check out this document on length contraction, which explains how observers in different frames of reference can measure different lengths for the same moving object. Pretty wild stuff.

So now, armed with this collection of documents, we’ll all be ready for the next time the aliens come down to Earth—ready to calculate the relative speed of their UFOs from the perspectives of various observers. That’ll show ‘em!

The pendulum and the cantilever share simple-looking ordinary differential equations (ODEs), but they are challenging to solve:

This post derives solutions from Lawden and Bisshopp by Maple commands, which (to the best of my knowledge) have not been published providing not only results but also the accompanying computer algebra techniques. A tabulated format has been chosen to better highlight similarities and differences.

Both solutions have in common that in a first step, the unknown function is integrated and then in a second step the inverse of the unknown function (i.e., the independent variable) is integrated. Only in combination with a well-chosen set of initial/boundary conditions solutions are possible. This makes these two cases difficult to handle by generic integration methods.

Originally, I was not looking for this insight. I was more interested in an exact solution for nonlinear deformations to benchmark numerical simulation results.  Relatively quickly, I was able to achieve this with the help of this forum, but after that I was left with some nagging questions:

Why does Maple not provide a solution for the pendulum although one exists?

Why isn’t there an explicit solution for the cantilever when there is one for the pendulum?

Why is it so difficult to proof that elliptic expressions are equal?

Repeatedly, whenever there was time, I came back to these questions and got more and more a better understanding of the two problems and the overall context. It also required me to learn more of Maple, and I had to revisit fundamentals of functions, differential equations, and integration, which was entirely possible within Maples help system. Today, I am satisfied to the point that I think it is too much to expect Maple to provide a high-level general integration method for such problems.

I am also satisfied that I was able to combine all my findings scattered across many documents and Mapleprime questions into a single executable textbook-style document with hidden Maple code that:

Exclusively uses and manipulates equation expressions (no assignment operators := were required),

Avoids differentials that are often used in textbooks but (for good reasons) are not supported by Maple,

Exclusively applies high-level commands (i.e. no extraction of subexpression, manipulation
           and subsequent re-assembly of expressions was needed).

The solutions for the pendulum and the cantilever are substantially different although the ODEs and essential derivation steps are similar. I think that an explicit solution for the cantilever, as it exists for the pendulum, is impossible (using elliptic integrals and functions). I leave it open to comments: whether this is correct and whether it is attributable to the set of initial and boundary conditions, the different symmetry of the sine and cosine functions in the ODEs, or both. I hope that the tabular presentation will provide an easy overview, allowing to form an own opinion.

If you are patient enough to work through the table, you will find a link between the cantilever and the pendulum that you are probably not expecting. 

Finally, I have to give credit to Bisshopp, who was probably the first to provide a solution for the cantilever. The clarity and compactness on only 3 pages and the way how the inverse of functions was determined before the age of computers makes this paper worth studying. Also, Lawden has to be mentioned, who did the same on 3 pages for the pendulum in a marvelous book on elliptic functions and applications. It happens that he is overlooked in more recent publications and it’s unclear to me if he was the first who published an explicit solution. His book might be one of the last of its kind in this age of computers, and for that reason alone, it is worth enjoying as he enjoyed writing it.

Download Cantilever_and_pendulum_side_by_side_-_input_hidden.mw

aRandStep2D := proc(X0, Y0, dx, dy)
  local X, Y, P, R;
  P := Array(1 .. 2);
  R := rand(1 .. 8)();
  if R = 1 then X := X0 - dx; Y := Y0 + dy; end if;
  if R = 2 then X := X0; Y := Y0 + dy; end if;
  if R = 3 then X := X0 + dx; Y := Y0 + dy; end if;
  if R = 4 then X := X0 - dx; Y := Y0; end if;
  if R = 5 then X := X0 + dx; Y := Y0; end if;
  if R = 6 then X := X0 - dx; Y := Y0 - dy; end if;
  if R = 7 then X := X0; Y := Y0 - dy; end if;
  if R = 8 then X := X0 + dx; Y := Y0 - dy; end if;
  P[1] := X; P[2] := Y;
  return P;
end proc 

SetStart := proc(b)
  local alpha, R, P;
  P := Array(1 .. 2);
  alpha := rand(1 .. b)();
  P[1] := alpha*b;
  P[2] := alpha*b;
  return P;
end proc 

RandomFactTpq := proc(N, pb, dx, dy)
  local alpha, X, Y, f, P, counter, B, n, T;
  P := Array(1 .. 2);
  counter := 0; f := 1;
  B := floor(evalf(sqrt(N))); #Set maximal searching steps
  T := floor(evalf(sqrt(N))); #For SetStart's use
  P := SetStart(T);
  X := P[1]; Y := P[2];
  while f = 1 and counter < B do  #loop
    n := pb - X - Y;
    f := gcd(N, n);
    if f > 1then break; end if;
    P := aRandStep2D(X, Y, dx, dy); #A random move
    X := P[1]; Y := P[2];
    if X < 1 or Y < 1 or N - pb - 1 < X or X <= Y then
      P := SetStart(T);       # Restart when out of borders
      X := P[1]; Y := P[2];
    end if;
    counter := counter + 1;    #Counting the searched steps
  end do;
  if  f>1  then print(Find at point (X, Y), found divisor = f, searching steps = counter);
  else print(This*time*finds*no*result, test*again!); end if;
end proc

wxbRandWalkTpqNew4.pdf