It might be a good idea to read some other word list (into a Maple list), rather than rely on the built-in pattern dictionary. It seems a little small, as indicated below by the examples which return NULL instead of returning at least the input string.

> with(StringTools): with(PatternDictionary):
> bid:= Create(`builtin`):
> words:= [seq](Get(bid,i),i=1..Size(bid)-1):

> Anagrams("nru",words);
                          "run", "urn"

> Anagrams("aterapse",words);
                           "separate"

> Anagrams("separates",words);

> Anagrams("redeem",words);

> Anagrams("modality",words);

> Anagrams("sparsity",words);

It was not hard to find missing words. Of course, you could still use StringTools:-Anagram, to find all anagrams of your input string in the given word list.

acer

Regarding your question 2, the idea seems premature in the sense that there are several other less difficult (but still difficult) requirements that would have to come first.

The big deal about high end GPUs is that they have lots of processing cores, and so are great for highly parallelizable tasks. Some (but not all) symbolic computation falls into that category. That qualification may be narrowed further as the full potential of general purpose graphical processing units (GPGPUs) appears more for floating-point computation, while much of Maple's symbolic computation involves integers and memory pointers (viz. DAGs).

In order to use a GPU for symbolics one would likely have to take something like one of the following paths:

A) make the interpreted Maple library thread-safe, port the kernel interpreter to the GPGPU runtime using efficient thread-supporting memory management, solve the problem of memory communiation latency to/from the GPGPU, solve other nasty issues I haven't thought of...

B) write a maple compiler that can handle exact symbolic maple language code, have that compiler emit thread-safe compiled code(!) with efficient thread-supporting memory management(!), make that compiler emit object code that can run on the GPGPU, solve the problem of memory communiation latency to/from the GPGPU, solve other nasty issues I haven't thought of...

It would be very nice to have just the first item in each of A) and B) along with a memory management system that handles threads well, even without regarding GPUs at all. The true power of the Maple Threads system which already exists for writing code to execute in parallel really could benefit from a thread-safe interpreted system Library and such a garbage collector. And a maple compiler that could handle symbolics would best the interpreted runtime , for even just serial calculations. None of these things is likely to be easy.

I think that a better, feasible short-term goal for GPGPUs under Maple could be a more general framework for numeric calculation on the GPU. By that I mean not merely a few (or even many) pre-made numeric routines like for FFTs, numeric pdes, linear algebra, etc. I mean for "user-defined" procedures. Such functionality might cover both custom procs for linear algebra computation (the data should all be pushed to the card once, at the start, and returned once at the end -- none of this up-down repeatedly for each stock GPU-capable command). Another nice piece of functionality would be for populating a data array -- push up a data rtable and a result rtable along with a compilable function with which to do a mapped populating job. That could be great for producing big 3D plots structures, assuming those could be just float[8] rtables.

acer

There's no easy way to get the error message to display the line number of the procedure in which an error occurs (without at least unprotecting and redefining the `error` command).

But for Library routines (ie. not kernel built-in commands) there is tracelast. For example,

> fsolve({x*y},x);
Error, (in fsolve) y is in the equation, and is not solved for

> tracelast;
 fsolve called with arguments: {x*y}, x
 #(fsolve,166): error "%1 is in the equation, and is not solved for", op(r)
Error, (in fsolve) y is in the equation, and is not solved for
 locals defined as: _X = x, eqns = {x*y}, eqns2 = eqns2, neqs = neqs, i = i, indx = indx, opt = opt, r = {y}, s = s, sol = sol, t = x, tvars = {x}, t1 = t1, ans = ans, temp = {}, procL = false, loceqs = loceqs, is_set = is_set, extra = ()

One can check that output, using `showstat` itself,

> showstat(fsolve,166);

fsolve := proc(eqs, vars)
local _X, eqns, eqns2, neqs, i, indx, opt, r, s, sol, t, tvars, t1, ans, temp, procL, loceqs, is_set, extra;
       ...
 166       error "%1 is in the equation, and is not solved for", op(r)
       ...
end proc

acer

Firstly, one might more normally use `mul` not `product` for multiplying together a finite number of terms.

But more relevant here is that `mul` is going to use `*`, and not the noncommutative `.` which is more what one wants for multiplying Matrices.

> <<1,2>|<3,4>> * <<5,6>|<7,8>>;
Error, (in rtable/Product) invalid arguments
> <<1,2>|<3,4>> . <<5,6>|<7,8>>;
                                  [23  31]
                                  [      ]
                                  [34  46]

Fortunately, `.` is not only a binary infix operator (eg. A . B) but is also an n-ary prefix operator (eg. `.`(A,B,C,E,...)) for an arbitrary finite number of arguments.

You could try this, then,

`.`(seq(MatrixExponential(I*Matrix(d,{(l,l)=1})*A[l,l]),l=1..d));

(I'm deliberately leaving aside discussion of how the final result of your particular example might be more easily obtained, as you could likely figure that out right away after seeing the result. I presume that this is merely a toy example to illustrate the issue with using `product`.)

acer

Suppose that one has a file foo.txt whose first line is this,

"C:\\TEMP\bar.txt" 13 gg

That can be scanned, and the first column's item (the string) converted, as follows,

> restart:
> fclose("C://TEMP/foo.txt");

> P:=fscanf("C://TEMP/foo.txt","%s %a %a");
                 [""C:\\TEMP\bar.txt"", 13, gg]

> # Make every \ into /
> StringTools:-SubstituteAll(P[1],"\\","/");
                      ""C://TEMP/bar.txt""

> # Alternatively, make both \\ and \ into //
> StringTools:-SubstituteAll(P[1],"\\\\","//"):
> StringTools:-SubstituteAll(%,"\\","//");
                     ""C://TEMP//bar.txt""

That last example should also cover the case of "c:\data\...", turning it into "c://data//..."

acer

Maple does contain a dictionary, but it also has a lot of jargon (ie. Maple, math) words in it.

> with(StringTools):
> with(PatternDictionary):

> dict:=Create('builtin'):
> L:=select(IsLower,select(IsAlpha,[seq](Get(dict,i),
>                                        i=1..Size(dict)-1))):

> twoletterwords:=select(z->length(z)=2,L);

 ["ad", "ah", "am", "an", "as", "at", "ax", "be", "by", "cf", 

   "do", "du", "eh", "el", "em", "en", "et", "ex", "go", "ha", 

   "he", "hi", "ho", "if", "ii", "in", "is", "it", "iv", "ix", 

   "la", "ln", "lo", "ma", "me", "mi", "mu", "my", "ne", "no", 

   "nu", "of", "oh", "on", "or", "ow", "ox", "pa", "pi", "re", 

   "sa", "so", "ti", "to", "up", "us", "vi", "we", "xi", "ye"]

> t2 := "abc": t3 := "def": t4 := "ghi": t5 := "jkl":
> t6 := "mno": t7 := "pqrs": t8 := "tuv": t9 := "wxyz":

> findem := proc(a,b)
> local T, numfound, thist, sol;
>    T:=combinat:-cartprod([[LengthSplit(a,1)],
>                           [LengthSplit(b,1)]]):
>    numfound:=0:
>    while not T[':-finished'] do
>       thist := cat(op(T[':-nextvalue']()));
>       if member(thist,twoletterwords) then
>          numfound:=numfound+1;
>          sol[numfound]:=thist;
>       end if;
>    end do:
>    convert(sol,list);
> end proc:

> findem(t4,t7);
                                   ["is"]

> findem(t2,t6);
                                ["am", "an"]

> findem(t3,t6);
                             ["do", "em", "en"]

That is by no means especially efficient. (For one thing, you could just make t2, t3, etc, into actual lists of single-characters, so that the procedure wouldn't ever have to split them more than once.)

acer

As shown in response to your duplicate post, you can specify a global solver for Optimization:-Maximize.

In this example, it may happen that the default local solver used by Maximize also returns the global maximum. But you can also force the method, with an option.

> with(Optimization):

> nx := Maximize(abs(.5547114632*x^2+1.130478381*x+.9883691714-exp(x)),
               x = -1 .. 1, method=branchandbound);

            nx := [0.0456887233851495, [x = -0.436328905794407]]

acer

For some reason, Maximize is using its "local" solver on this problem by default.

> restart:

> with(Optimization):

> infolevel[Optimization]:=1:

> nx := Maximize(
>         abs(.5539395590*x^2+1.130864333*x+.9891410756-exp(x)),
>         x=-1.0..1.0); # "local solver"

NLPSolve: calling NLP solver
NLPSolve: using method=quadratic
NLPSolve: number of problem variables
            nx := [0.0452333936742979, [x = -0.438621263028586]]

> nx := Maximize(
>         abs(.5539395590*x^2+1.130864333*x+.9891410756-exp(x)),
>         x=-1.0..1.0,method=branchandbound); # "global solver"

NLPSolve: calling NLP solver
NLPSolve: using method=branchandbound
NLPSolve: number of problem variables
             nx := [0.0454683311488107, [x = 0.560938672728197]]

acer

The command from the Optimization package is Maximize, not maximize.

> with(Optimization):
> nx := Maximize(abs(.5547114632*x^2+1.130478381*x+.9883691714-exp(x)),
>                x = -1 .. 1);

            nx := [0.0456887233851494, [x = -0.436328906042811]]

> restart:
> nx := Optimization:-Maximize(
>                abs(.5547114632*x^2+1.130478381*x+.9883691714-exp(x)),
>                x = -1 .. 1);

            nx := [0.0456887233851494, [x = -0.436328906042811]]

acer

Capitalization matters in Maple. The command from the Optimization package is Maximize, not maximize.

> with(Optimization):

> nx := Maximize(abs((29.83428688*x-57.16914857)/(x-2.196093020)-exp(x)),
>                x = 5.0 .. 6.0);
                     nx := [371.399468551146, [x = 6.]]

> restart:
> Optimization:-Maximize(abs((29.83428688*x-57.16914857)/(x-2.196093020)-exp(x)),
>                x = 5.0 .. 6.0);
                        [371.399468551146, [x = 6.]]

acer

Since you've now seen the `expand` command, here's some more Maple that might help you,

> L := [-1/2,2/3,7/3,4+3*I,4-3*I];

                  [-1  2  7                  ]
                  [--, -, -, 4 + 3 I, 4 - 3 I]
                  [2   3  3                  ]

> facp := mul((x-r), r in L);

   /    1\ /    2\ /    7\                                  
   |x + -| |x - -| |x - -| (x + (-4 - 3 I)) (x + (-4 + 3 I))
   \    2/ \    3/ \    3/                                  

> p:= expand(facp);

            5   21  4   175   811  3   373  2   29  
           x  - -- x  + --- + --- x  - --- x  - -- x
                2        9    18        6       6   

[solve(p)];

                  [-1  7  2                  ]
                  [--, -, -, 4 - 3 I, 4 + 3 I]
                  [2   3  3                  ]

and `fsolve` is an alternative to `solve` that you could find useful for higher degree univariate polynomials.

acer

It can get trickier, if there are more "mismatches" at the range ends. A procedure can be constructed which uses a single intermediate that seems to do the trick (in at least some more cases).

> combminus:=proc(s::specfunc(anything,Sum),t::specfunc(anything,Sum))
>    local temp;
>    if op(1,s) = op(1,t) then
>       temp:=Sum(op(1,s),i=op(1,rhs(op(2,s)))..op(2,rhs(op(2,t))));
>       value(combine(s-temp)+combine(temp-t));
>    else
>       s-t;
>    end if;
> end proc:


> s1 := Sum(x(i), i = n-1 .. m-1):
> s3 := Sum(x(i), i = n+1 .. m+1):

> value(combine(s3-s1));

              /  m - 1         \   /  m + 1      \
              | -----          |   | -----       |
              |  \             |   |  \          |
              |   )            |   |   )         |
              |  /      (-x(i))| + |  /      x(i)|
              | -----          |   | -----       |
              \i = n - 1       /   \i = n + 1    /

> combminus(s3,s1);

               x(m) + x(m + 1) - x(n - 1) - x(n)

# The single intermediate s2 (as in DuncanA's Answer) does not suffice alone.
# (Not that anyone has claimed it would, of course.)
> s2 := Sum(x(i), i = n .. m):

> value(combine(s3-s2)
>       +combine(s2-s1));

     /  m + 1      \   /  m          \   /  m - 1         \
     | -----       |   |-----        |   | -----          |
     |  \          |   | \           |   |  \             |
     |   )         |   |  )          |   |   )            |
     |  /      x(i)| + | /    (-x(i))| + |  /      (-x(i))|
     | -----       |   |-----        |   | -----          |
     \i = n + 1    /   \i = n        /   \i = n - 1       /

          /  m       \
          |-----     |
          | \        |
          |  )       |
        + | /    x(i)|
          |-----     |
          \i = n     /

# No need to introduce this many intermediates,
# as `combminus` solved it above.
> s2_a := Sum(x(i), i = n .. m-1):
> s2_b := Sum(x(i), i = n+1 .. m-1):
> s2_c := Sum(x(i), i = n+1 .. m):

> value(combine(s3-s2_c)
>       +combine(s2_c-s2_b)
>       +combine(s2_b-s2_a)
>       +combine(s2_a-s1));

               x(m) + x(m + 1) - x(n - 1) - x(n)

# Another example.
> s1 := Sum(x(i), i = n-1 .. m+1):
> s3 := Sum(x(i), i = n .. m-1):

> value(combine(s3-s1));

               /  m + 1         \   /m - 1     \
               | -----          |   |-----     |
               |  \             |   | \        |
               |   )            |   |  )       |
               |  /      (-x(i))| + | /    x(i)|
               | -----          |   |-----     |
               \i = n - 1       /   \i = n     /

> combminus(s3,s1);

                  -x(m) - x(m + 1) - x(n - 1)

acer

with(Student:-NumericalAnalysis):
de:=diff(y(t),t)=-exp(3*y(t)),y(0)=1:
P1:=RungeKutta(de,t=1,submethod=rk4,output=plot,numsteps=10,
               plotoptions=[color=green]):
P2:=Euler(de,t=1,output=plot,numsteps=10,
          plotoptions=[color=black]):
plots:-display([P1,P2]);

Maybe someone can show how to make the legend better, showing the colored symbols.

acer

The problem is that the units in numerator and denominator do not simplify and cancel by default.

> a/(b+t*Unit(kg));

                      7 Unit('kg')            
             -----------------------------
             10 Unit('kg') + t Unit('kg')

You can make them "cancel" in several ways.

> a:=7*Unit(kg):
> b:=10*Unit(kg):

> y:=t->ln(a/(b+t)):
> plot(combine(y(t*Unit(kg)),units));

> y:=proc(t) uses Units:-Standard;
>            ln(a/(b+t)); end proc:
> plot(y(t*Unit(kg)));

> y:=t->ln(a/(b+t)):
> plot(simplify(y(t*Unit(kg))));

acer

There are issues with 1) automatically detecting oscillatory integrands and consequent automatic determination of the appropriate method, and 2) automatic determination of the number of subintervals into which to split the range.

Mma used to fail on some similar problems, and issue a message about the user's needing to specify a larger number of subintervals. Getting rid of that need may be what has improved in Mma 8.

In Maple 14, one can do it this way (similar in princpal to Mma's decribed older behaviour),

> st:=time():
> evalf(Int(cos(log(x)/x), x = .0001 .. 1));
                          0.3247340117
> time()-st;
                             2.094

> evalf(Int(cos(log(x)/x), x = .0001 .. 1, method=_d01akc));
Error, (in evalf/int) NE_QUAD_MAX_SUBDIV:
  The maximum number of subdivisions has
  been reached: max_num_subint = 500

> st:=time():
> evalf(Int(cos(log(x)/x), x = .0001 .. 1, maxintervals=2000, method=_d01akc));
                          0.3247340117
> time()-st;
                             0.156

The two things to see above is that I had to specify the method which I knew was "best" for the stated problem. And I had to manually increase the number of subintervals. Note that it was not always possible to even raise the subinterval number in Maple. See this old thread.

If Wolfram has figured out a reliable way to do it automatically, quickly, then... well done. There's thus room for further improvement in Maple too.

There's also room for improvement in Maple in the area of oscillatory numeric integrals over semi-infinite regions, which is a form that can also occur with a change of variables....

> Y:=Int(cos(log(x)/x), x = 0 .. 1);

                         /1              
                        |      /ln(x)\   
                        |   cos|-----| dx
                        |      \  x  /   
                       /0                

> student[changevar](y=1/x,Y,y);

                    /infinity    /  /1\  \   
                   |          cos|ln|-| y|   
                   |             \  \y/  /   
                   |          ------------ dy
                   |                2        
                  /1               y         

> op(1,%);

                             /  /1\  \
                          cos|ln|-| y|
                             \  \y/  /
                          ------------
                                2     
                               y      

> plot(%,y=1..30);

Look at how that plot decays. Imagine a scheme for oscillatory integrals for semi-infinite ranges which could quickly handle the above. Who knows, maybe that's what Mma 8 is actually doing?

acer