The On-Line Encyclopedia of Integer Sequences (OEIS) is an online database of integer sequences. Originally founded by Neil Sloane in 1964, OEIS has evolved into a larger community based project that today contains information records on over 280,000 sequences. Each record contains information on the leading terms of the sequence, keywords, mathematical motivations, literature links, and more - there’s even Maple code to reproduce many of the sequences!

You can read more about the OEIS project on the main site, or on Wikipedia. There have also been several articles written about the OEIS project; here’s a (somewhat) recent article on Building a Searching Engine for Mathematics that gives a little more history on the project.

I wrote a simple package for Maple that can be used to search OEIS for a sequence of numbers or a string and retrieve information on various integer sequences. You can interact with the OEIS package using the commands: Get, Search or Print, or using the right-click context menu.

Here are some examples:

Search for a sequence of 6 or more numbers (note that you can also just right-click on an integer sequence to run the search):

Retrieve information on the integer sequence A000081. By default, this returns the data as a JSON string and stores the results in a table:

Entries in the table can be accessed as follows:

I’ve also added some functionality for printing tables containing information on integer sequences. The Print command displays an embedded table containing all or selected output from records. For example, say we search for a sequence of numbers:

Let’s print out selected details on the first three of these sequences (including Maple code if available):

The OEIS API is somewhat limited, so I have had to put some restrictions in place for returning results. Any query that returns more than 100 entries will return an error and a message to provide a more precise specification for the query. Also, in order to reduce the number of search results, the Search command requires at least 6 integers.

You can install the OEIS package directly from the MapleCloud or by running:

Comments and feedback are welcome here, or on the project page: https://github.com/dskoog/Maple-OEIS

I write shell scripts that call Maple to automate frequent tasks. Because I prefer writing Maple code to shell code, I've created a Maple package, Bark, that generates a shell script from Maple source code. It provides a compact notation for defining both optional and positional command-line parameters, and a mechanism to print a help page, from the command-line, for the script. The optional parameters can be both traditional single letter Unix options, or the more expressive GNU-style long options.

As an example, here is the Maple code, using Bark, for a hello-world script.

hello := module()
export
    Parser := Bark:-ArgParser(NULL
                              , 'prologue' = ( "Print `Hello, World!'" )
                              , 'opts' = ['help' :: 'help' &c "Print this help page"]
                             );
export
    ModuleApply := proc(cmdline :: string := "")
        Bark:-ArgParser:-Parse(Parser, cmdline);
        Bark:-printf("Hello, World!\n");
        NULL;
    end proc;
end module:

The following command creates and installs the shell script in the user's bin directory.

Bark:-CreateScript("hello", hello
                   , 'add_libname' = Bark:-SaveLib(hello, 'mla' = "hello.mla")
                  ):

The hello script is executed from the command-line as

$ hello
Hello,  World!

Pass the -h (or --help) option to display the help.

$ hello -h
Usage: hello [-h|--help] [--]

Print `Hello, World!'

Optional parameters:
-h, --help Print this help page

CreateScript creates two files that are installed in the bin directory: the shell script and a Maple archive file that contains the Maple procedures. The shell script passes its argument in a call to the parser (a Maple procedure) saved in the archive file (.mla file). Here's the created shell script for the hello command:

#!/usr/bin/env sh
MAPLE='/home/joe/maplesoft/sandbox/main/bin/maple'
CMD_LINE=$(echo $0; for arg in "$@"; do printf '%s\n' "$arg"; done)
echo "hello(\"$CMD_LINE\");" | "$MAPLE" -q -w2 -B --historyfile=none -b '/home/joe/bin/hello.mla'

I've used Bark on Linux and Windows (with Cygwin tools). It should work on any unix-compatible OS with the Bash shell. If you use a different shell that does not work with it, let me know and I should be able to modify the CreateScript command to have options for specific shells.

Bark is available on the MapleCloud. To install it, open the MapleCloud palette in Maple, select packages in the drop-down menu and go to the New tab (or possibly the Popular tab). You will also need the TextTools package which is also on the MapleCloud. The intro page for Bark has a command that automatically installs TextTools. Alternatively, executing the following commands in Maple 2017 should install both TextTools and Bark.

PackageTools:-Install~([5741316844552192,6273820789833728],'overwrite'):
Bark:-InstallExamples('overwrite'):

The source for a few useful scripts are included in the examples directory of the installed Bark toolbox. Maple help pages are included with Bark, use "Bark" as the topic.

I am pleased to announce that a new release of Maple T.A., our online testing and assessment system, is now available. Maple T.A. 2017 includes significant enhancements to learning management system integration, as well as security, performance, and other improvements. These same improvements are also available in a new version of the  Maple T.A. MAA Placement Test Suite.  For more information, see What’s New in Maple T.A. 

As my first project as a Junior Applications Developer, I set out to learn to code in the best way I know how, by doing.  I ended up picking what was probably one of the hardest options I could pick, namely to replicate the sliding puzzle game, 2048. (https://en.wikipedia.org/wiki/2048_(video_game) ) Of course I didn’t realize how hard it would be at the time, but after spending the first week alone working on the logic, I had already dug my hole.

2048, the sliding puzzle game, basically starts with a 4x4 grid filled with zeros. As you swipe the grid, values move toward one of the up, down, left or right sides. With every subsequent swipe, a randomly placed value of 2 or 4 is added to the grid. Any neighbouring matching values in the direction of the swipe are added to one another. This was done by swiping 2 tiles of equal value into each other, creating a new tile with double the value. Two 2 tiles became a 4, two 4’s an 8, and so on.

The goal? To create a 2048 tile.

Overall the logic was probably the most challenging part of my task, once the framework was set. . The logic consisted of many if statements that made the numbers “slide” properly, ie not combining with another number. This was probably the hardest part. Troubleshooting and allowing for all the possible conditions also proved difficult. However, the user interface was probably the toughest part, figuring out the labels, making everything display correctly, and programming all the buttons to not break. That was fun.

Anyway, it was a really fun project to work on, and I’m extremely happy for how it turned out, and I hope you enjoy playing it, as much as I did making it!

You can try it out here:

https://maple.cloud/#doc=5765606839156736

Hello,

I often use in Maple the plot preview, but any time when i launch the plot preview, i must set the zoom factor to 100% to see all content of the document and further i have to maximize theplot-view window.

It is very uncomfortable to use the plot preview.

This should be fixed with the next upgrades of Maple.

See here the effect, when launching the plot previewer:

Thanks in advance

Volker

With a member of the community I had some discussion about using Maple for limits of sequences.

The specific task was about F:=4*sqrt(n)*sin(Pi*sqrt(4*n^2+sqrt(n))) and limit F for n --> infinity for integers, which is asserted to be Pi, see https://math.stackexchange.com/questions/2493385/find-the-limits-lim-n4-sqrtn-sin-pi-sqrt4n2-sqrtn.

For moderate size of integers n it can be 'confirmed' by numerical evaluations. Formally it is not 'obvious' at all.

However Maple answers by

limit(F, n = infinity) assuming n::posint;

                              undefined

This is 'explained' by the help about assuming/details:

"The assuming command does not place assumptions on integration or summation dummy variables in definite integrals and sums, nor in limit or product dummy variables, because all these variables already have their domain restricted by the integration, summation or product range or by the method used to compute a limit. ..."
The help continues with suggestions how to treat the situation.

Which means that the limit is taken in the Reals, not in the discrete Naturals.

A more simple example may be limit(sin(n*Pi), n = infinity) assuming n::posint which returns "-1 .. 1".

But here we go:

MultiSeries:-asympt(F, n):
simplify(%) assuming n::posint: collect(%, n); #lprint(%);
limit(%, n=infinity);

   O(1/2048*Pi^3/n^(5/2)) + Pi -1/96*Pi^3/n - 1/16*Pi/n^(3/2) + 1/30720*Pi^5/n^2

                                  Pi

As desired.

As you know, the MapleCloud is a good way to share all sorts of interactive documents with others, in private groups or so they are accessible to everyone. We recently posted some new content that I thought people might be particularly interested in: a collection of Maple Assistants.

Up until now, Maple Assistants were only available from within Maple, but now you can take advantage of these powerful tools wherever you are, using your web browser.

Code Generation  - Translate Maple code to C, Java, Python, R, and more

Scientific Constants – Explore over 20000 values of physical constants and properties of chemical elements, including units and uncertainty values

Special Functions – Explore the properties of over 200 special functions, including the Hypergeometric, Bessel, Mathieu, Heun and Legendre families of functions.

Units Converter – Convert between over 500 units of measurement. (In addition to the standard stuff, you can find out how many fortnights old you are, or how long your commute is in furlongs!)

I have just posted an article with this title at Maplesoft Application Center here.
It was motivated by a question posed by  Markiyan Hirnyk  here and a test problem proposed there by Kitonum.

Now I just want to give the promissed complete solution to Kitonum's test:

Compute the plane area of the region defined by the inequalities:

R := [ (x-4)^2+y^2 <= 25, x^2+(y-3)^2 >= 9, (x+sqrt(7))^2+y^2 >= 16 ];

plots:-inequal(R, x=-7..10, y=-6..6, scaling=constrained);

The used procedures (for details see the mentioned article):

ranges:=proc(simpledom::list(relation), X::list(name))
local rez:=NULL, r,z,k,r1,r2;
if nops(simpledom)<>2*nops(X) then error "Domain not simple!" fi;
for k to nops(X) do    r1,r2:=simpledom[2*k-1..2*k][]; z:=X[k];
  if   rhs(r1)=z and lhs(r2)=z then rez:=z=lhs(r1)..rhs(r2),rez; #a<z,z<b
  elif lhs(r1)=z and rhs(r2)=z then rez:=z=lhs(r2)..rhs(r1),rez  #z<b,a<z
  else error "Strange order in a simple domain" fi
od;
rez
end proc:

MultiIntPoly:=proc(f, rels::list(relation(ratpoly)), X::list(name))
local r,rez,sol,irr,wirr, rels1, w;
irr:=[indets(rels,{function,realcons^realcons})[]];
wirr:=[seq(w[i],i=1..nops(irr))];
rels1:=eval(rels, irr=~wirr);
sol:=SolveTools:-SemiAlgebraic(rels1,X,parameters=wirr):
sol:=remove(hastype, eval(sol,wirr=~irr), `=`); 
add(Int(f,ranges(r,X)),r=sol)
end proc:

MeasApp:=proc(rel::{set,list}(relation), Q::list(name='range'(realcons)), N::posint)
local r, n:=0, X, t, frel:=evalf(rel)[];
if indets(rel,name) <> indets(Q,name)  then error "Non matching variables" fi;
r:=[seq(rand(evalf(rhs(t))), t=Q)];
X:=[seq(lhs(t),t=Q)];
to N do
  if evalb(eval(`and`(frel), X=~r())) then n:=n+1 fi;
od;
evalf( n/N*mul((rhs-lhs)(rhs(t)),t=Q) );
end proc:

Problem's solution:

MultiIntPoly(1, R, [x,y]):  # Unfortunately it's slow; patience needed!
radnormal(simplify(value(%)));

evalf(%) = MeasApp(R, [x=-7..10,y=-6..6], 10000); # A rough numerical check
           61.16217534 = 59.91480000

This presentation is about magnetic traps for neutral particles, first achieved for cold neutrons and nowadays widely used in cold-atom physics. The level is that of undergraduate electrodynamics and tensor calculus courses. Tackling this topic within a computer algebra worksheet as shown below illustrates well the kind of advanced computations that can be done today with the Physics package. A new feature minimizetensorcomponents and related functionality is used along the presentation, that requires the updated Physics library distributed at the Maplesoft R&D Physics webpage.
 

MagneticTraps.mw or in pdf format with the sections open: MagneticTraps.pdf

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

Much of this topic is developed using traditional techniques. Maple modernizes and optimizes solutions by displaying the necessary operators and simple commands to solve large problems. Using the conditions of equilibrium for both moment and force we find the forces and moments of reactions for any type of structure. In spanish.

Equlibrium.mw

https://www.youtube.com/watch?v=7zC8pGC4F2c

Lenin Araujo Castillo

Ambassador of Maple

Since 2002, the Texas A&M Math Department has sponsored a Summer Educational Enrichment in Math (SEE-Math) Program for gifted middle school students entering the 6th, 7th or 8th grade under the direction of Philip Yasskin and David Manuel.  Students spend two weeks exploring ideas from algebra, geometry, graph theory, topology, and other mathematical topics. 

The program’s primary goal is to help students find excitement in the discovery of mathematics and science concepts, and to provide them with the knowledge and confidence to continue their studies in math and science related fields. “I love working with the bright young kids who come to SEE-Math, they keep me young,” said Yasskin, one of the programs directors.

Maplesoft has been a sponsor of SEE-Math for many years and are happy to see the students explore math at this young age. Research into the importance of early math skills shows that children who are taught math early and learn the basics at a young age are set up for a lifetime of achievement in all aspects of their academic performance.  Every year, Maplesoft commits time, funds and people to various organizations to enhance the quality of math-based learning and discovery and to encourage students to strengthen their math skills.

One of the major activities of the SEE-Math program, and something the students really enjoy doing, is creating computer animations in Maple. The kids are divided into 3 groups; the Euler group is mostly made up of 6th graders with a few younger, the Fibonacci group is mostly 6th and 7th graders, and the Gauss group is 7th and 8th graders.

 Here are the 2017 first place winners from each group and their animations:

Euler Group - Nigel M "Buckets"

Fibonacci Group - Gabriel M "Skillz"

Gauss Group - Michael C - "Newton's Castle"

To learn more about this program visit: http://see-math.math.tamu.edu/2017/

Good book to start studying maple for engineering.

Download Australopithecus_updated.mw

http://www.gatewaycoalition.org/includes/display_project.aspx?ID=279&maincatid=105&subcatid=1019&thirdcatid=0

Lenin Araujo Castillo

Ambassador of Maple

In this application you can visualize the impulse generated by a constant and variable force for the interaction of a particle with an object in a state of rest or movement. It is also the calculation of the momentum-momentum equation by entering the mass of the particle to solve initial and final velocities respectively according to the case study. Engineering students can quickly display the calculations and then their interpretation. In spanish.

Plot_of_equation_impulse-momentum.mw

Exercises_of_Momentum-Impulse_Linear.mw

Lenin Araujo Castillo

Ambassador of Maple

While many of us in North America were getting re-acquainted with the Fall routine, Maplesoft was involved in a major event, the Maple T.A. and Möbius User Summit. In the past, the Summit has alternated locations between Europe and North America, but following the success of last year’s Summit in Vienna, Austria, we recently broke new ground and expanded the reach of the event to include more countries around the world in order to localize the themes and to meet the growing demand from educators to take learning online.

The first event, organized by Cybernet, took place in China. The second of five events on the calendar took place in London, England. Held from September 7-8, this installment was a major stop in the tour, drawing many residents of the UK to hear talks from some of our strongest proponents of Möbius in Europe. The London Summit drew several delegates from the UK alone, many of whom were completely new contacts for us! Other attendees came from as far away as Russia, Pakistan, Sri Lanka, and Australia, as well as some from Sweden, Denmark, Italy and the Netherlands. The turnout was brilliant!

Make progress or make excuses

The bulk of the London Summit was divided into three driving themes: Showcasing the Successful Delivery of Online Education; Best Practices for Digital Testing and Assessment; and Creating Engaging and Interactive Online STEM Content. Each theme consisted of 3 user presentations delivered by representatives from renowned institutions like University of Manchester, University of Birmingham, London Imperial College, University of Waterloo, Chalmers University of Technology, and more.

Maplesoft Application Engineer Surak Perera may have inadvertently set the tone for the day when he kicked off theme 1 with a quote from Tony Robbins: Make progress, or make excuses. One thing’s for sure – excuses were nowhere to be found at One Moorgate Place. The audience was captivated and engaged, and wasted no time bouncing questions and ideas off of our presenters. In fact, they were so eager to learn from our Maple T.A. and Möbius users that Jonny Zivku, Maple T.A. Product Manager, had to interject several times in order to keep the schedule moving! Each presentation reinforced the ability of Maple T.A. and Möbius to be used for diverse purposes such as distance education or analyzing incoming students, and in a range of subjects including multidisciplinary engineering cohorts, or simply core mathematics. Each presenter demonstrated that these tools can take you as far as the user’s mind is willing to be stretched.

Evening Reception

As heads were getting full and bellies were getting empty, the group left the luxuries of modern day and stepped back into what must have felt like a scene from Downton Abbey in the Main Reception Room of the venue. On the menu was the most culturally appropriate dish: fish and chips! Oh, and don’t forget the tea and wine!

There was no better way to wrap up the Summit than with Steve Furino’s interactive presentation and open discussion “Collecting Data about Collecting Data.” Small group discussion enabled the attendees to reconcile their inspiration from Day 1 with the practicality of putting it into practice once they return to their schools.

Overall, the London Summit was a smashing hit. The centralized location drew attendees who had a lot of common experiences which made for optimal discussion. The final question posted was the most revealing of everyone’s experience: where will the Summit be next year?

While that’s not yet decided, the Toronto Summit – the next stop in the Summit Series – is just a fortnight away (November 2-3). So for now, we’re saying “Cheers” to jolly good times in London, and “Can I get a double-double, eh” to Toronto!

Until then, you can experience the London Summit as if you were there with the full presentation proceedings and videos. They’re now available on our website!

So I have recently finished up a project that took different sounds found in nature, and through the Spectrogram command, plotted the frequency of each sound over time with some really cool results!

https://www.maplesoft.com/applications/view.aspx?SID=154346 

The contrast between sounds produced by the weather such as tornadoes, thunder, and hail versus something as innocuous as a buzzing bee, a chorus of crickets, or a purring cat really shows the variance in the different sounds we hear in our day to day life, while also creating some very interesting imagery.

My personal favourite was the cricket chorus, producing a very ordered image with some really cool spikes through many different frequencies as the crickets chirped, as shown here:

Using this plot, we can do some interesting things, like count the number of chirps in 8 seconds, which turns out to be 18-18.5. Why Is this important? Well, there’s a law known as Dolbear’s Law(shown here: https://en.wikipedia.org/wiki/Dolbear%27s_law)  which uses the number of chirps in a minute for Fahrenheit, or 8 seconds for Celsius to calculate the temperature. Celsius is very simple, and just requires adding 5 to the number of chirps in 8 seconds, which gets us a temperature of 23C.

T_c= 5 + N₈

For Fahrenheit, it’s a bit more complicated, as we need the chirps in a minute. This is around 132 chirps in our case. Putting that into the formula:

T_F= 50 +((N₆₀ – 40)/4)

Which gets us 73F, or 22.7C, so you can see that it works pretty well! Pretty cool, huh?

There was also some really cool images that were produced, like the thunder plot:

Which I personally really like due to the contrasting black and yellow spike that occurs. Overall this was a very fun project to do, getting to tweak the different colours and scales of each spectrogram, creating a story out of a sound. Hope you all enjoy it!