My understanding is that the original relation is x*sin(x*y)=x. So you cannot just assume sin(x*y)=1.  That follows if x <> 0, however, using sin(x*y)=1 in the Maple simplification begs the question. One could just start with that...

My understanding is that the original relation is x*sin(x*y)=x. So you cannot just assume sin(x*y)=1.  That follows if x <> 0, however, using sin(x*y)=1 in the Maple simplification begs the question. One could just start with that...

Your description makes sense, your add statement does not (remember, i is assigned the members of the list, not the indices). Here is one method to do what you want

add(`if`(L[i]=2 and L[i+1]=3, L[i], 0), i=1..nops(L)-1);

Your description makes sense, your add statement does not (remember, i is assigned the members of the list, not the indices). Here is one method to do what you want

add(`if`(L[i]=2 and L[i+1]=3, L[i], 0), i=1..nops(L)-1);

I don't understand.  The test i+1=4 is equivalent to i=3.  Could you explain what you intend? Note that i is assigned the elements of L, not the indices.

I don't understand.  The test i+1=4 is equivalent to i=3.  Could you explain what you intend? Note that i is assigned the elements of L, not the indices.

The disjoint cycle notation is a list of lists (e.g., [[1,2],[3,4]]), so that should be

a := [[1,2]]:
b := [[2,3]]:

A simple way to define a group multiplication operator is

`&*` := group:-mulperms:

Then

a &* b;
               [[1, 3, 2]]

The disjoint cycle notation is a list of lists (e.g., [[1,2],[3,4]]), so that should be

a := [[1,2]]:
b := [[2,3]]:

A simple way to define a group multiplication operator is

`&*` := group:-mulperms:

Then

a &* b;
               [[1, 3, 2]]

They are very similar.  The significant difference is that a cache table has a maximum size, while a remember table can continue to grow.  When a cache table is filled, older entries may be replaced with newer ones.  You can specify the size of a cache table in the option statement, see ?option,cache.  If the size of the cache table were a problem, in the example, you could reduce the required space by sorting the arguments in the recursive call (the function is symmetric).

They are very similar.  The significant difference is that a cache table has a maximum size, while a remember table can continue to grow.  When a cache table is filled, older entries may be replaced with newer ones.  You can specify the size of a cache table in the option statement, see ?option,cache.  If the size of the cache table were a problem, in the example, you could reduce the required space by sorting the arguments in the recursive call (the function is symmetric).

I'm not sure what you are asking.  Disjoint cycle notation was used for the computation of the produce, the result was then converted to list notation. Do you want to see an explicit list notation, that is similar to what you wrote?  For example, one could write the list notation [3,1,2] as [[1,2,3],[3,1,2]], where the first list is the "domain".  A procedure to generate that is trivial. 

I'm not sure what you are asking.  Disjoint cycle notation was used for the computation of the produce, the result was then converted to list notation. Do you want to see an explicit list notation, that is similar to what you wrote?  For example, one could write the list notation [3,1,2] as [[1,2,3],[3,1,2]], where the first list is the "domain".  A procedure to generate that is trivial. 

Dual-axis plot can be viewed using the tty interface (command-line maple) if the plotset(maplet) command is first issued. I assume that that would also work under Classic, but haven't tried it (my normal interface to Maple is the tty interface, via Emacs).  Alas, it does not appear possible to export to postscript, either directly (with plotsetup(ps)) or from the Maplet; it returns an error complaining about the _DUALAXIS element.

Are you specifically interested in a discrete series? Or just the concept of using frequency transformations to compute the the convolution via multiplication. Here is a simple example using continuous-time functions and the ?inttrans package:

f := t^2:
g := t+1:
F := inttrans[laplace](f,t,s);
                                         2
                                   F := ----
                                          3
                                         s

G := inttrans[laplace](g,t,s);
                                       1 + s
                                  G := -----
                                         2
                                        s

H := F*G;
                                     2 (1 + s)
                                H := ---------
                                         5
                                        s

h := inttrans[invlaplace](H,s,t);
                                      3
                                     t  (4 + t)
                                h := ----------
                                         12

Are you specifically interested in a discrete series? Or just the concept of using frequency transformations to compute the the convolution via multiplication. Here is a simple example using continuous-time functions and the ?inttrans package:

f := t^2:
g := t+1:
F := inttrans[laplace](f,t,s);
                                         2
                                   F := ----
                                          3
                                         s

G := inttrans[laplace](g,t,s);
                                       1 + s
                                  G := -----
                                         2
                                        s

H := F*G;
                                     2 (1 + s)
                                H := ---------
                                         5
                                        s

h := inttrans[invlaplace](H,s,t);
                                      3
                                     t  (4 + t)
                                h := ----------
                                         12