Items tagged with blog blog Tagged Items Feed

This is the first in a series of short informal articles about our efforts to speed up polynomial arithmetic in Maple. We begin with an example of how polynomials are represented in Maple right now.

Maple sum structure

9xyz  -  4yz  -  6xyz  -  8x  -  5

When you enter a polynomial in Maple, it creates a generic data structure like the one above. In Maple's representation this polynomial is a sum of terms that is 11 words of memory long where each word is either 32 or 64 bits. For each term it stores a pointer to a monomial followed by a coefficient.

Making a dash for it...

November 19 2009 acer 10106 Maple

An attempt at question 2 of the xkcd Velociraptor Math problem (mentioned on this blog post). The parameters and events facilities of

Classic on XP64...

November 19 2009 acer 10106 Maple

There is no released Classic interface to accompany the 64 bit version of Maple (12, 13) for the 64 bit Windows XP64 operating system. Personally, I prefer running the Standard over the Classic interface, although sometimes I miss common subexpression display for lengthy symbolic output.
The Maple Classic interface appears to talk to the Maple kernel only over a socket (or similar), and the...

% in a proc...

September 19 2009 acer 10106 Maple

Could there be a useful performance gain if Maple were changed so that %, %%, and %%% did not function inside a procedure (proc) body?

Should one ever use % in a procedure? Would using it just be obfuscation where none is needed, or could it serve a special purpose?

While on this topic, how good or bad would it be to use a Standard GUI equation label inside the body of a proc that was entered in 2D Math?


saving localness...

September 03 2009 acer 10106 Maple

Not all objects can be saved to .m and retrieved sucessfully in a restarted or new session. This is the case not only for "escaped" locals, but also for some objects implemented as function calls of a module member.

> restart:

> t := ScientificConstants:-Constant('c'):

> type(t, specfunc(anything,ScientificConstants:-Constant));
> ScientificConstants:-GetValue(t...

I was just reminded of an aspect of Maple GUI Components, new to Maple 13, that has sometimes come in very useful to me. It is the ability to refresh a component programatically.

I should explain. The old (and current default) behaviour is for the GUI not to refresh any other components until the current component is finished (ie. returns control).

The relevant situation in which this matters is when a given component has action code whose

On some Linux distributions, the default font (Lucida Bright at size 12) for text mode in Maple's Standard GUI doesn't look as good as it might at the default magnification.

Here's a screenshot of Maple 12 and some text in a worksheet (on my very old Fedora Core 2).

fortuna's wheel...

March 07 2009 acer 10106 Maple

I was considering what sorts of "normally coded" things might get broken by the loading of a Maple Library package and the ensuing rebinding of names.

And so I tried this,

> with(RealDomain): # rebinds sin

> convert( cos(x), sin );
                                     sin(2 x)
                                 1/2 --------

I was actually surprised to see that work OK. I was expecting `convert`...

The following type of difference in behaviour, due to deterministic ordering of sets as introduced in Maple 12, may affect implementations of some algorithms.

    |\^/|     Maple 11 (X86 64 LINUX)
._|\|   |/|_. Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2007
 \  MAPLE  /  All rights reserved. Maple is a trademark of
 <____ ____>  Waterloo Maple Inc.
      |       Type ? for help.

> seq(x, x in {a,b,c,d,e,f,g}) assuming d>0;

This is a follow-up to an earlier post about CovarianceMatrix.

There are several ways in which Statistics:-CorrelationMatrix can be improved.

CorrelationMatrix shares some inefficiencies with CovarianceMatrix, by computing correlations between the n columns, pairwise. But in doing so it also computes...

Some years ago, before the advent of the Statistics package, a colleague asked for a fast way to generate thousands of normally distributed random numbers in Maple. The suggestion that worked quickest and most easily (using existing, simple Maple Library routines) was to generate random deviates using the usual formula associated with the distribution. But the key was to replace the scalar values (representing the uniformly distributed input) with a whole Matrix of input values....

Every now and then someone will post here on Mapleprimes and the code will use an older package such as linalg or stats. Quite often it is clear that the poster is new to Maple. Yet these packages have been superceded with new ones, eg. LinearAlgebra and Statistics.

One obvious question that then arises is: how did this user decide to use the older package?

I just did a google search on

Over on the usenet newsgroup comp.math.soft-sys.maple, someone asked about using Maple's overload facility to redefine the operators such as `*`, `+`, etc.

The difficulty for the submitter is that while overload (and option overload for procedures) can provide enhanced operators for new routines, it doesn't affect routines saved in the Maple Library which already have their bindings. Overloading does not subsequently change the bindings of the operators when used in (most all) Library routines.

One way to try and get around this is to actually redefine the global operators. And since overload is on topic, one can still use it in the replacements that one writes.

In order to redefine global operators one must first unprotect them. They are protected for a very good reason. If the replacements are not adequate then Maple can fail in a multitude of ways. It's a case of caveat emptor.

What single change in Maple would you want more than any other?

Maybe it's an enhancement, or a functionality change, or a bug fix.

It looks like `forget` works on procedures with option 'cache'.

I realize that there is a routine Cache:-RemovePermanent. But should `forget` be clearing the permanent Cache entries for a procedure?

> cacheFunc := proc() option cache; print(args); args; end proc:
> Cache:-AddPermanent( cacheFunc, [5], 10 );
> op( 4, eval(cacheFunc) );
                      Cache(512, 'permanent' = [5 = 10])
> forget(cacheFunc);
> op( 4, eval(cacheFunc) ); # NULL return, it's empty
3 4 5 6 7 Page 5 of 7