How about just the following, if the file name is test.txt.

M := parse~(ImportMatrix("test.txt",delimiter=" "));

You would replace test.txt with the fully qualified file name, according to its actual location on your machine, or first call currentdir( ) appropriately.

Download binomialcdf.mw

Download polygen.mw

Was the restriction on a subsequently added to the Question?

Download limitparam.mw

You could have a look at this old discussion thread (and the links to yet older discussions, in my Answer there).

The reason that you see "so many" solutions is that by default for your example solve computes both real and complex solutions.

If you only want purely real solutions of your system of polynomial equations then pass the additional option real to the solve command.

Download solvepolysysreal.mw

It is simply -> which are the keystrokes minus - , and greater-than > .

You can have a blank space before or after them, but no space between them.

As for the manual, see this section of the Programming Guide.

The following was all done in a terminal session (Command Line Interface, or CLI).

( x->sin(x)+x )( 5 );                                                                        

                     sin(5) + 5

( x -> sin(x)+x )( 5 );                                                                      

                     sin(5) + 5


map( x->sin(x)+x, [2,3,7] );                                                                 

          [sin(2) + 2, sin(3) + 3, sin(7) + 7]

f := x->sin(x)+x;                                                                            

                 f := x -> sin(x) + x

f(t);                                                                                        

                     sin(t) + t

expr := cos(x)^2;                                                                            

                                  2
                    expr := cos(x)

g := unapply( expr, x );                                                                     

                                  2
                  g := x -> cos(x)

g(t);                                                                                        

                         2
                   cos(t)

x -> tan(x)^2;                                                                               

                          2
               x -> tan(x)

proc(x) option operator, arrow; tan(x)^2; end proc;

                          2
               x -> tan(x)

Why do you expect the conjugate on r^(1/4) to resolve just because r is assumed real? You seem to be overlooking the possibility that r could be negative.

Download conj.mw

Let us know if you want to build these things programmatically and have any trouble with that (it should be pretty straightfroward). Or if you want additional aspects like color, or fonts/color/weight on 2D Math.

Download plottitlefont.mw

While the ShowSolutions command fails on this example (because of the presence of parameter s, I suspect), a step-by-step solution is still attainable.

Download stepbystepexample.mw

The case of a parsing error can be handled by doing the parse before calling dsolve. And you could put that in a try...catch and deal with it as you prefer.

When there is no previous parsing error, there's no hard set of rules that will always allow you to distinguish subsequently between cases like your 1.) and 2.), for arbitrary commands. It varies from command to command.

You can often make some distinctions of case 3) versus the other two, according to lastexception[1] which you have not utilized yet. It will often denote which named procedure emitted the error. So you could programmatically test -- or otherwise distinguish -- between the case that dsolve threw the error or some other procedure did. For example, simply printing it:

Download lastexception1.mw

ps. Please don't delete your question once someone's responded and you've resolved your difficulty, as like last week on stackexchange.

The situation you're describing involves what's called a optional positional parameter.

You should use the quote-protected global name as the default value, to avoid problems such as when the global name is already assigned a value.

Eg,

restart;

sim := proc( x, n,
             o::identical(exactly,maximum,minimum) := ':-exactly' )
          return o;
       end proc:

sim();
                            exactly

exactly := 4:

sim();
                            exactly

That also helps avoid undesirable side-effects even if exactly were an unevaluated function call. (Such situations do occur.) Defensive programming is a good habit -- and I'll advocate it even if I don't always follow my own advice.

Your expectation is not valid.

Perhaps you meant to query   max(abs(Q))  ?

Download suuual_ac.mw 

One way that the error message "bad index into Array" can occur is where Maple tries to access the Array using a non-numeric index.

A typical example would be where Maple tries to access, say, Y[i] where the name i does not yet have an integer value. Eg,

restart;
Y := Array(1..10, i->i):

Y[i];
Error, bad index into Array

The seq command has special evaluation rules, which prevents Y[i] from being evaluated until i gets actual values. So this works.

restart;
Y := Array(1..10, i->i):

seq(Y[i], i=1..10);
               1, 2, 3, 4, 5, 6, 7, 8, 9, 10

But the sum command does not have special evaluation rules. The following produces the same error as does the first example above,

restart;
Y := Array(1..10, i->i):

sum(Y[i], i=1..10);
Error, bad index into Array

What just happened was that Maple tried to evaluate the first argument passed to the sum call before i got any value, which is Maple's usual evaluation rules for procedure calls. But, for what you are trying to accomplish, the Array reference Y[i] was evaluated prematurely.

Here are two alternative ways to do summation involving Array elements:

1) Use the add command instead of the sum command, since the add command also has special evaluation rules.

restart;
Y := Array(1..10, i->i):
add(Y[i], i=1..10);
                           55

2) Delay the indexed Array reference using unevaluation quotes (single right-quotes).

restart;
Y := Array(1..10, i->i):
sum('Y[i]', i=1..10);
                           55

Now, I am guessing that this kind of premature evaluation of an indexed Array reference is your problem, mostly based on your use of the words, "summation index" and the particular error message you cited. If I've guess wrongly then please provide the full example.

I'll note that at least one other Answer seems to be indicating that you've accessed Array entries using invalid numeric values for the index. I suspect that is not your problem, however, mostly because the error message for that situation is different than your Question's title.

restart;
Y := Array(1..10, i->i):

seq(Y[i+1]-Y[i], i=1..10);
Error, Array index out of range

seq(Y[i+1]-Y[i], i=0..9);
Error, Array index out of range

On MS-Windows and Linux you can use the keyboard short-cuts Ctl-r to temporarily switch from text mode to 2D Input mode, and Ctl-t to switch back.

On Mac OS X I believe that it's similar, Cmd-r and Cmd-t .

See the help-pages for more.