jakubi

Yesterday I have came across with this thread, while browsing the list of "Unanswered Questions". As it started quite recently (May 11) I did remember that I have posted some answers there. So I inspected it and found the already classical problem that all the answers were not taken into account just because they were classified as "Comment". Once more, I note that answering in Primes 1...

I have just seen this old thread in the "Recent" list, and, as I remember it well and because of curiosity, I have looked at it again. By browsing it, I have noted that as it stands right now, it makes little sense. As I keep a local Primes 1 backup, I have compared both and got a new unpleasant surprise to be added to the list brought by Primes 2: many posts (ten or more) in this thread, by Jacques, Joe, mine, etc, are missing, and the order of some remaining posts is altered. 

Has anyone compared timings of Maple executing under Windows XP and Windows 7? It means, with the same PC and booting in either OS.

Jacques,

[reply to this post]

I know a lot of the history of Axiom (having had many talks about it with James Davenport over the last 6 months), NAG, Maple, etc.

What about if, as result of those talks, you (both?) write a comparative review about the main design ideas of either system and their impact on past and future development?

I am not receiving email notifications from subscribed threads since about two days ago, without any change on my side. Has anyone else experienced this same problem?

Consider routine A in the library, which is called by routines B1, B2,..,BN.
Then, any change in A affects, potentially, the behavior of all of them. And
B1 is in turn called by C1,...,CM, which are also, potentially, affected, etc.
But there may be routines in no way, directly or indirectly dependent on A.

Is there a way to trace the sectors of the library dependent or independent of
a given routine?

 

In the volume Advanced Programming Guide of the Maple manual, the "clasical" picture of the Maple system architecture is depicted:

 A1: Internal Organization

Components

Maple consists of three main components: a kernel, a library, and a user interface. The kernel and library together are known as the math engine.

Kernel The kernel is written in the C language and is responsible for low-level operations such as arbitrary precision arithmetic, file I/O, execution of the Maple language, and the performance of simple mathematical operations such as differentiation of polynomials.

Library Most of the Maple mathematical functionality is in the Maple library, which is written in the Maple language. The library is stored in an archive, and pieces of it are loaded and interpreted by the kernel on demand.

User Interface The user interface is the part of Maple that the user sees, and is conceptually separate from the math engine. The same math engine can be used with different user interfaces.

However, the architecture of the system has been moving away from this picture for several years already. Eg:

A second parser has been implemented in the Standard GUI, instead of the kernel.

As some expressions involving 'floor' and 'ceil' did not simplify as I have expected, I have gone to basics. In ?trunc > Description it is stated:

ceil(x) = -floor(-x)

But 'simplify' does not seem to know about this equation as this expression should simplify to 0:

simplify(ceil(x)+floor(-x));

                         floor(-x) + ceil(x)

In principle, this seems to be a weakness in 'simplify'. For comparison, in Mathematica 5:

For a single pair of left single quotes, ?name is clear:

Any valid Maple name formed without using left single quotes is precisely the same as the name formed by surrounding the name with left single quotes.

So this is fine:

`x`;
                      x

But what about multiple left single quotes? This help page also states:

I find that for some plots the choice of location for tickmarks and axes labels in the Classic version is better than the Standard one. Eg. here:

with(plots):
complexplot3d(sin(z), z=-Pi-1.5*I..Pi+1.5*I,axes=boxed,
style=surfacecontour,tickmarks=[[-Pi=-Pi,0=0,Pi=Pi], 
default,default],orientation=[72,49]); 

Classic:

Which is the difference between them? (besides being builtin or not). For the simple examples that I have tested, their output seems the same, eg:

`convert/function`(f,[1]);
                                 f(1)

`?()`(f,[1]);
                                 f(1)

To be "updated" I have defined in Maple 12 an "identity function" using '_passed', but the output shows 'args':

id:=()->_passed; 
                           id := () -> args

Based on the paragraph:

Prior to Maple 10, _passed and _npassed were called args and nargs. For backward compatibility, these names will continue to work as synonyms for the new names.

from ?using_parameters, I find this result unexpected. In fact, I would have expected the other way round, ie that here:

Let me call them this way. I wonder whether there is a "conversion" table between these names. Examples:

After ?invtrig:

For real arguments x, y, the two-argument function arctan(y, x), computes the principal value of the argument of the complex number x+I*y, so -Pi < arctan(y, x) <= Pi.

For any point in C or R^2 (x,y)<>(0,0) the geometrical meaning of this result is clear: the angle that the segment/vector from (0,0) to (x,y) forms with the x-axis. But this angle is undefined if this point is the origin.

So, what is arctan(0,0)?, and what it should be?

In ?property > Description it is stated:

A property can be:
...
(2) most types (this includes constant values, for example, 0)

E.g. I can do:

assume(x,1):
about(x);

Originally x, renamed x~:
  is assumed to be: 1

is(x,1);
                                    true

But, I am missing a useful example for such a property.

Besides, I find these properties confusing as 0 and 1 have parent properties entries in the property lattice, but not 2: