The revelant commands are DEtools[DEplot] or dsolve followed by plots:-odeplot. If you have parameters, I think the dsolve / odeplot route would be easiest. If you want more help, you'll need to post your system of ODEs, their initial conditions, and your desired values of the parameters.

This is a common operation---not at all a "strange question."

The ApproximateInt command, if given exact symbolic input, attempts to compute the exact value of the integral approximation. What you want is a floating-point approximation. To get such, you simply need to include a decimal point in the function or in the interval of integration:

f:= x^2/(sin(x)+x+1.;
Student:-Calculus1:-ApproximateInt(f, x= 1. .. 2., method= simpson, partition= 20);

This'll produce the decimal answer very quickly. Only one the decimal points above is needed.

To make plots go to a separate window, use the command

plotsetup(window);

These plots will look normal even if run from the command-line interface (that which you're calling maple-terminal).

One potential problem with this is that every plot goes to a new window, and I know of no programmatic way to close the windows. So, if you make 1000 plots, you'll have a 1000 open windows.

SimpleStack is an object-oriented module-based implementation; stack is a much older table-based implementation. SimpleStack has all the functionality of stack and some additional functionality. SimpleStack uses a more-familiar programming paradigm. I use SimpleStack exclusively.

Recursive procedures are very easy in Maple:

catalan:= proc(n::nonnegint)
option remember;
local k;
     add(thisproc(k)*thisproc(n-1-k), k= 0..n-1)
end proc:

#Put initial value in remember table.
catalan(0):= 1:

catalan(9);

     4862

By preloading the initial value into the remember table, we avoid the need to check for initial values in the procedure itself. This is more efficient.

A proper Maple function doesn't "print" a value; it returns a value. It's left up to the user whether or not to print the value.

`&ll`:= (a,b)-> 1/(1/a+1/b):
3 &ll 7;

In Maple, a^(1/3) is not real for a < 0. The real cube root is accessed by surd(a,3). So, change the plot command to

plot3d(surd(1-x^3-y^3, 3), x= -10..10, y= -10..10);

One way is to use the sequencing operator $:

1/2^k $ k= 4..8;

Although this operator is less efficient than the more common seq, it has the benefit of being capable of abstraction, which seq lacks:

MySeq:= 1/2^k $ k= a..b;

eval(MySeq, [a= 4, b= 8]);

Unlike seq, the k in the above expression should be either unassigned or placed in unevaluation quotes:

1/2^'k' $ 'k'= a..b;

When the number of equations is different from the number of variables being solved for, it's usually a bad idea to use solve. Use eliminate instead. The syntax is the same; just change solve to eliminate.

eliminate(
     [a = -(-y+1)/(x-y+2),
      b = -(-x^2+2*x*y-y^2-3*x+3*y-2)/(x-2*y+3),
      c = -(x*y-y^2-2*x+4*y-4)/(x*y-y^2-x+2*y-1),
      d = -(-x*y+y^2+x-2*y+1)/(x-2*y+3)
      ], [x,y]
);

The second set is expressions that equal 0. So you can think of it as providing solutions for b and c.

You removed your code from your Question. That isn't a good sign.

Anyway, here is a very fast way to generate a large number of your random walks using directions sampled from your probability distribution.

Download RandDirWalk.mw

Array plots won't display in MaplePrimes, but you'll see in the worksheet that every walk is plotted on its own set of axes.

Regarding your followup question where you want to form the conjugate i*j*i^(-1) for every pair of elements i, j in A: It can be done like this:

B:= {seq(seq(PermConjugate(i,j), i= A), j= A)};

This computation takes about a minute because there are 705600 pairs. The end result is simply the set A again (no surprise).

You can essentially enter them as in the book, and then make some substitutions: y to y(x), dy to diff(y(x), x) and dx to 1. Also, I've never seen arctg or tg. I just changed these immediately to arctan and tan, respectively.

Download 6_ODEs.mw

The correct syntax for the select command is

A:= select(g-> PermOrder(g)=4, H);

Think of it as having this English translation: "Select g such that PermOrder(g)=4 from H."

It's never allowed for an indexed name such as H[i] to be a left-side operand of ->, i.e., a parameter. That was the proximate cause of your error message.

I posted code for extracting the extrema from plots, so you're not "on your own" as Mac Dude says. The code can be found here:

http://www.mapleprimes.com/questions/206660-Maximum-Point-Of-Plot#answer221288

The commands that are (guaranteed to be) thread safe are listed in the help page ?index,threadsafe. Unfortunately, it's a very small list.