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
  • MaplePrimes is a place that allows you to do many things. A question that people may wonder is, “how do I start?
    Within MaplePrimes, you will have the ability to post applications, exchange applications, etc. The primary difference between MaplePrimes and the Application Center is really about quality levels. For the Application Center, there is a review process an some editorial interaction with the author before it is published and ultimately, Maplesoft makes the decision. Within MaplePrimes, your application, its quality, and all other elements of it, are your responsibility. Some may want to only show their best polished work while others may wish to solicit comments on incomplete works to assist in development.
    We want to be an inclusive community. As long as people participate within the community guidelines, we welcome them. As with all moderated communities however, difficult choices must be made occasionally to ensure the ongoing effectiveness and health of the site. Legally speaking, we do reserve the right to deny access to individuals whom the site moderators deem to be counter to the interest of the community. We will exercise this right sparingly.
    Often constructive criticism is essential for the health of an online community. We want open discussions. When criticisms go beyond the boundaries of being constructive and linger in the realm of flames, vents, and personal attacks, the moderators may deem it necessary to conclude the debate. In addition, there will be a "zero tolerance" policy for content that crosses the boundaries into illegal, libelous, and other forms of destructive content.
    MaplePrimes was the name that was used for our exclusive access site for our Extended Maintenance Program (EMP) sites. Maplesoft has launched a new program for maintenance – the Elite Maintenance Program. The EMP program will soon be launching a new website within that will replace the old MaplePrimes, but also will bring more benefits. The name MaplePrimes is now used for Maplesoft's band new user community. The new MaplePrimes will help to serve more Maple users. It allows all users, including those who are not EMP customers to interact together and get even more out of their use of Maple. MaplePrimes is a web community dedicated to sharing experiences, techniques, and opinions about Maple and related products, as well as general interest topics in math and computing. Using the framework of blogs, forums, and an open editorial policy, it provides a vehicle for enthusiasts to present their thoughts, and for inquiring minds to get answers.
    Anything officially sanctioned or funded by a corporation can be interpreted as a marketing ploy. Yes Maplesoft genuinely hopes that MaplePrimes is a positive influence on the market and that people will learn more and continue to support the Maplesoft business as a consequence of their experiences on this site. However, we have taken great pains to establish suitable distance from corporate policies and the editorial elements of the site. Our goal is to establish a truly community-driven site. However at the outset, in order to achieve critical mass of participants, MaplePrimes will initially have greater direct participation by Maplesoft staff.
    It is moderated and in some sense all forms of content moderation is some form of censorship. Our moderation policies, however, embody the spirit of open collaboration and we will try our best to allow open discussion while limiting illegal, disrespectful, overly inflammatory, and clearly unconstructive content. Initially, moderation will be performed by Maplesoft though the intent is to migrate towards a community-moderating concept. In general, however, we will not establish an unmoderated community. There are already good alternatives for that within the newsgroups and other discussion groups.
    Welcome to MaplePrimes -- a new Web community for Maple users and enthusiasts. This site is designed to offer a dynamic, moderated environment for you to get answers, get new tools, and share your work with the world.

    Since the topic of MaplePrimes is Mathematics, we have made it easy to have your postings on the site contain attractive formatted math notation. There are two major ways of doing this.

    I've been completely unsatisfied with the Maple LaTeX output. So, with the help of Joe Riel on comp.soft-sys.math.maple, I've created a procedure to use instead of a call to the latex command called simpleLaTeX. I've attached to this entry a Maple 9.5 worksheet that contains the procedure and a sample of its use. I'd appreciate any feedback people might have or further suggestions. Please send me any modifications you might make to the procedure. It seems to work quite well for all the test expressions I've sent to it.
    Since I was walking around the conference with my Nikon D70 hanging around my neck, many people asked me how they will be able to view the photos that I took at the conference.
    The second day of the 2005 Maple conference was another busy day at Wilfred Laurer University. The day began with an excellent keynote presentation from Dr. Richard Gran, the CEO of Mathematical Analysis Company. His talk began with him recalling his days working on the Lunar Module for the Apollo moon missions. It was quite a pleasure to see this man speak.
    I would like to give a big welcome to everyone who just found out about this site at the Maple Conference. I hope that all of you will find the site to be very useful and enjoyable to use. For those of you who are not attending the conference, it is Maplesoft's annual gathering of Maple users. This year it is taking place at Wilfred Laurier University in Waterloo, Ontario.

    A while ago, I was trying to determine the fastest way, using Maple, to compute a list of a particular sequence of integers defined by a recurrence relation. This isn't a new idea of course, but I think the exercise is a useful introduction into the various ways of coding algorithms in Maple, and why some may be better than others.

    My original example was a bit esoteric, so for simplicity I've redone it using the standard example of a recurrence relation, the Fibonacci sequence. We'll fix N, the number of Fibonacci numbers to compute, at 40000.

    > N := 40000:

    Below, we'll try to find the fastest way, in Maple, to compute a list of these numbers from scratch. Note that the speed comparisons might be specific to this machine, OS, or Maple version, and even though the runtime of most of these implementations is about the same, the fastest method at N=40000 might not be the fastest one for larger N.

    The first idea is the completely naive approach. We'll store the Fibonacci numbers in a Maple list L, step through a loop counting up the sequence, and in each loop iteration add to the list with L := [op(L), new_element].

    f1 := proc(N)
        local i, L;
        L := [1, 1];
        for i from 2 to N do
            L := [op(L), L[-2] + L[-1]];
        end do;
    end proc:

    The problem with this approach is that Maple lists are not intended to be grown in this way, and each redefinition of the list L costs O(N) time, making the whole procedure O(N).

    > time(f1(N));

    From now on we'll use only implementations that take O(N) time, and see how they compare.

    The next implementation uses a Maple table stored as a local variable of a module. We compute the sequence and assign it to table entries, and at the end generate a Maple list from these table entries. The use of tables is advantageous because tables can be dynamically grown more efficiently than lists can, but this approach has the disdvantage that the table must be completely re-traversed in the last step to generate the list.

    f2 := module()
        local ModuleApply, T;

        T := table([0=1, 1=1]);

        ModuleApply := proc(N)
            local i;
            for i from 2 to N do
                T[i] := T[i-2] + T[i-1];
            end do:
            [seq(T[i], i=0..N)]
        end proc:
    end module:

    You'll see that since this code avoids list-appending, it's quite a bit faster:

    > time(f2(N));

    The next idea is to do essentially what we did above, but using remember tables rather than built-in Maple tables. We'll pre-populate the remember table for the utility procedure p with entries for the base cases, F0 and F1, and then build our list through recursive calls.

    f3 := module()
        local p, ModuleApply;

        p := proc(n) option remember;
            procname(n-2) + procname(n-1)
        end proc:

        p(0) := 1;
        p(1) := 1;
        ModuleApply := proc(N)
            [1, 1, seq(p(i), i=2..N)]
        end proc:
    end module:

    As we might expect, the computed result is pretty close (but a bit higher than) our last number.

    > time(f3(N));

    One disadvantage of the last two approaches is that they both rely on creating an intermediate data structure of size O(N) (the table or remember table), which is promptly discarded, since what we're interested in is a list. Instead we can use a 'cache', which is a new feature of Maple 9.5, and is essentially a remember table of bounded size.

    f4 := module()
        local p, ModuleApply;

        p := proc(n) option cache;
            procname(n-2) + procname(n-1)
        end proc:

        p(0) := 1;
        p(1) := 1;

        ModuleApply := proc(N)
            [1, 1, seq(p(), i=2..N)]
        end proc:
    end module:

    It works out to be slightly slower than f3; this may be because of the time taken in garbage-collecting the information from the cache.

    > time(f4(N));

    Next, I've tried to implement something like a cache, without actually using one. Here we have a utility procedure with two counters, which represent the last and second-last Fibonacci number respectively. The procedure updates the values and returns the appropriate one. We'll build the list with recursive calls to this procedure. Like the cache, the intermediate data structures used here are of bounded size, since there are just two of them.

    f5 := module()
        local p, n1, n2, ModuleApply;

        n1 := 1;
        n2 := 1;

        p := proc(n)
            (n1, n2) := (n2, n1+n2);
        end proc:

        ModuleApply := proc(N)
            [1, 1, seq(p(), i=2..N)]
        end proc:
    end module:

    It's about the same speed as using the cache, which is impressive since it involves a lot more procedure calls into the procedure body than the cache example, which mostly consisted of calls into the cache.

    > time(f5(N));

    Finally, mostly for completeness, we try to see we get by pre-allocating an Array and adding to that. Arrays can be modified inplace in O(1) time, but cannot be dynamically grown. Here we make an array of the appropriate size, fill it, then convert it to a list.

    f6 := proc(N)
        local A, i;
        A := Array(0..N, {0=1,1=1});
        for i from 2 to N do
            A[i] := A[i-2] + A[i-1];
        end do:
        convert(A, 'list')
    end proc:

    It's about as fast as the previous two examples, and has the advantage of simplicity of design. However, building the array and converting that to a list is another instance of using large intermediate data structures, which we avoided with the previous two examples.

    > time(f6(N));

    So it looks like f2 is the winner in this very specialized contest. This probably has more to do with the quirks of this example than any difference in efficiency of the code concerned. And if minimizing intermediate memory use is the goal, then f4 or f5 would be preferable.

    There are two ways of directly entering math into MaplePrimes. The first is the <maple> tag. Any text between <maple></maple> tags will be interpreted as Maple syntax and be replaced with a 2D GIF image of that syntax.

    First 286 287 288 289 290 291 Page 288 of 291