If the Maple content (input and output) is fixed, it sounds to me that the route is export the Maple worksheet to html and then postprocess.

If the Maple content (input and output) is fixed, it sounds to me that the route is export the Maple worksheet to html and then postprocess.

That can be done continuously from the console using the 'tail' command like:

tail -f filename

It can be done also on Windows as there win32 implementations of 'tail'.

I do not see this way of logging to be unusual but quite standard, faster, easier, and more reliable.

That can be done continuously from the console using the 'tail' command like:

tail -f filename

It can be done also on Windows as there win32 implementations of 'tail'.

I do not see this way of logging to be unusual but quite standard, faster, easier, and more reliable.

Presumably, RootOf(a^3-1,index=1) is precisely that. Indeed:

RootOf(a^3-1,index=1);
convert(%,radical);
                               3
                      RootOf(_Z  - 1, index = 1)

                                  1

but, apparently, 'factor' has problems with this:

factor(x-1,RootOf(a^3-1,index=1));

Error, (in evala) reducible RootOf detected.  
Substitutions are {RootOf(_Z^3-1,index = 1) = 1, 
RootOf(_Z^3-1,index = 1) = RootOf(_Z^2+_Z+1)}

I do not understand what this error message exactly means as:

allvalues(RootOf(_Z^2+_Z+1));
                               1/2                 1/2
                - 1/2 + 1/2 I 3   , - 1/2 - 1/2 I 3

different from 1.

they have been unable to handle yet. After three months of repeated and detailed reports on crashes I have received an answer with this paragraph:

However I should remind you that the Maple Classic interface is a legacy interface and that I cannot make any guarantee on the time-frame in which our developers will be able to answer your questions.

they have been unable to handle yet. After three months of repeated and detailed reports on crashes I have received an answer with this paragraph:

However I should remind you that the Maple Classic interface is a legacy interface and that I cannot make any guarantee on the time-frame in which our developers will be able to answer your questions.

By the way, ?compiletable states:

The compiletable([pattern1=entry1, pattern2=entry2, ...]) calling sequence creates an efficient lookup table by merging patterns (with parameters) into a tree that the pattern matcher (tablelook command) can search in logarithmic time.

But I had the impression, eg from other threads at Mapleprimes, that operations on a list-based structure are significantly slower than equivalent operations on a table-based structure. Is such time difference also true in this case?

By the way, ?compiletable states:

The compiletable([pattern1=entry1, pattern2=entry2, ...]) calling sequence creates an efficient lookup table by merging patterns (with parameters) into a tree that the pattern matcher (tablelook command) can search in logarithmic time.

But I had the impression, eg from other threads at Mapleprimes, that operations on a list-based structure are significantly slower than equivalent operations on a table-based structure. Is such time difference also true in this case?

One way is by using unevaluation quotes (' '):

for i to 2 do
'X'[i]=X[i];
end do;
                             X[1] = 7/54


                                     -1
                              X[2] = ---
                                     324

In a worksheet (both Classic and Standard GUI) I get:

q:=4;
                                q := 4

while in Standard GUI document mode I get just 4. May be that there is a setting to change this default, but I do not use the document mode.

One way is by using unevaluation quotes (' '):

for i to 2 do
'X'[i]=X[i];
end do;
                             X[1] = 7/54


                                     -1
                              X[2] = ---
                                     324

In a worksheet (both Classic and Standard GUI) I get:

q:=4;
                                q := 4

while in Standard GUI document mode I get just 4. May be that there is a setting to change this default, but I do not use the document mode.

It may depend on how you made the assumptions. You should show your code. See this example:

interface(showassumed=1):
assume(x,real):
a:=x;

                               a := x~

assume(x,real):
a-x;

                               x~ - x~

This last expression will not simplify to 0 as a different 'x~' variable is generated each time that an assumption is made. They just print the same on screen.

It may depend on how you made the assumptions. You should show your code. See this example:

interface(showassumed=1):
assume(x,real):
a:=x;

                               a := x~

assume(x,real):
a-x;

                               x~ - x~

This last expression will not simplify to 0 as a different 'x~' variable is generated each time that an assumption is made. They just print the same on screen.

You could do instead:

for i to op(1,solution1) do
X||i:=solution1[i];
end do;

                              X1 := 7/54


                                    -1
                              X2 := ---
                                    324

You could do instead:

for i to op(1,solution1) do
X||i:=solution1[i];
end do;

                              X1 := 7/54


                                    -1
                              X2 := ---
                                    324