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

Did you not already ask that here, and see the posted answer?

nb. As mentioned there, a list in Maple is entered using [] square brackets, not {} brackets which are for sets.

acer

The HFloat underperforms compared, say, to immediate integers.

restart:
kernelopts(gcfreq=[10^7,0.0000001]):
st:=time():
for i from 1 to 5 do
  for j from 1 to 10^6 do
    HFloat(j);
  end do;
  gc();
  print([kernelopts(bytesalloc),kernelopts(bytesused),kernelopts(gctimes)]);
end do:
time()-st;
                  [104903924, 4037634432, 341]
                  [104903924, 4076101300, 342]
                  [104903924, 4113039968, 343]
                  [104903924, 4150709568, 344]
                  [104903924, 4188603216, 345]
                             7.515

restart:
kernelopts(gcfreq=[10^7,0.0000001]):
st:=time():
for i from 1 to 5 do
  for j from 1 to 10^6 do
    j;
  end do;
  gc();
  print([kernelopts(bytesalloc),kernelopts(bytesused),kernelopts(gctimes)]);
end do:
time()-st;
                   [851812, 4192460624, 347]
                   [851812, 4192462656, 348]
                   [851812, 4192464632, 349]
                   [851812, 4192466544, 350]
                   [851812, 4192468488, 351]
                             0.719

restart:
kernelopts(gcfreq=[10^7,0.0000001]):
st:=time():
for i from 1 to 5 do
  for j from kernelopts(maximmediate) to kernelopts(maximmediate)+10^6 do
    j;
  end do;
  gc();
  print([kernelopts(bytesalloc),kernelopts(bytesused),kernelopts(gctimes)]);
end do:
time()-st;
                  [61723608, 4257649624, 353]
                  [61723608, 4285651840, 354]
                  [61723608, 4313653832, 355]
                  [61723608, 4341655848, 356]
                  [61723608, 4369657836, 357]
                             3.422

acer

When you use the "Apply a Command" entry from the context-sensitive menus, you can use this command in the pop up entry box (typed just as you see it below, including brackets):

(evalc@abs,evalc@argument)

Did you know that you can also customize the context-menus, by adding (new, or more complicated) commands, optionally with their own "annotations above the arrow"? So if you want you can add a new item that does just the phase conversion you want, in one shot. And it could be annotated however you wanted. And you could put it in your Maple initialization file so that it was available in all you new sessions, or in a particular Document's "start up region" so that anyone else could re-execute it. See here for some notes on customizing the context menus. Ask for help, if you want to try it but run into difficulties.

acer