Regarding double precision: There is a scalar HFloat constructor. You can also store them in datatype=float[8] rtables, and do arithmetic on those. You can operate with double precision floats under evalhf mode, including passing in float[8] rtables. You can also operate with them in procedures treated by Compile:-Compile.

Regarding single precision: You can store single precision floats in datatype=float[4] rtables. With some effort you may be able to get arithmetic on those via external calling to MKL (not sure, it's picky).

For fun (and you could fix this up for negative values, I expect),

restart;

x := 0.25;
                           x := 0.25

h := convert(ArrayTools:-Alias(Vector([x],datatype=float[4]),
                               integer[4])[1],hex);

                         h := 3E800000

ArrayTools:-Alias(Vector([convert(h,decimal,16)],
                         datatype=integer[4]),float[4])[1];

                       0.250000000000000

restart;

x := 0.33;
                           x := 0.33

h := convert(ArrayTools:-Alias(Vector([x],datatype=float[4]),
                               integer[4])[1],hex);
                         h := 3EA8F5C3

ArrayTools:-Alias(Vector([convert(h,decimal,16)],
                         datatype=integer[4]),float[4])[1];

                       0.330000013113022

You may compare this with results obtained here (including the close radix-10 value obtained when reversing the process, compared to what that site describes as, "Most accurate representation = 3.300000131130218505859375E-1".)

plots:-shadebetween(sin(x), cos(x), x = -Pi .. Pi, gridlines = true);

Download plot3d_ivp_param.mw

Calling plot3d the other way, as,
    plot3d(Zf(t,f), t=0..3, f=1..10, grid=[49,29])
takes about 3.6 minutes on my machine.

You could open a command line shell in your Operating System, and call Maple's Command Line Interface executable with the name of a text file containing Maple code.

For example, on Linux in a terminal window,

    /usr/local/maple/Maple2018/bin/maple  myfile.mpl

where file myfile.mpl is a plaintext file of Maple code.

On MS-Windows it might be something like,

   "C:\\Program Files\Maple 2018\bin.X86_64_WINDOWS\cmaple.exe"  myfile.mpl

(For MS-Windows, Inside a Maple session, including inside a Maple GUI session, you can issue the Maple command kernelopts(bindir) to see the location of the cmaple.exe executable.)

You can read about the options supported by the CLI executable on the Maple Help page with topic maple .

In the very first nested double loop of the worksheet (over i and j), there are assignments to PDE[5][i, j] and other PDE[..] entries.

In the assignment to PDE[5][i, j] there is an instance of chi without indices, in a subexpression like,

    ( chi+(sum(C[1][j, k]*W[i, k], k = 1 .. M))/lambda2 )

This seems like a mistake.

Later on, chi is replaced with a Matrix, so that subexpression seems to not make sense.

If I (guess and) change that to chi[i,j] then a valid system of equations gets passed to fsolve, and a numeric root is found for that system.

test_fsolve_ac.mw

One approach is to construct a Worksheet/Document that looks how you want it (pair of empty input lines, say), save it somewhere, and then make that your custom "start page".

Eg,  From the main menubar, Tools -> Options -> Interface and change the drop-menu item Open worksheet at startup to  Specified worksheet . Make that point at your saved file. Optionally, set that file as read-only in your Operating System, outside of Maple, so that you don't accidentally overwrite it once you start work. That is, always do Edit -> Save As before any Edit -> Save, to save new work to a new file.

You should then always be able to get to this template using the "start page" icon from the menubar, which looks like a house.

Thomas's answer is good and useful.

But, since you asked about sum, it could be noticed that there is a difference in behavior for eval versus limit of the reciprocal of that factorial call. And sum can try to use both.

restart;

eval(1/(n-1)!, n=0);
Error, numeric exception: division by zero

eval(1/GAMMA(n), n=0);
Error, (in GAMMA) numeric exception: division by zero

limit(1/GAMMA(n), n=0);
                               0

limit(1/(n-1)!, n=0);
                               0

So, when n is considered real (as under your sum examples), the limit of the reciprocal comes out as zero (even though the limit from left and right of the factorial call are infinity with opposite signs).

In the following attachment, sum does try to evaluate factorial with argument -1, early on. When that fails it can try limit instead (on the reciprocal expression) and get the 0 result.

factorial_sum_numericvent.mw

Use the stopat and unstopat commands to insert and remove DEBUG() calls within the procedure body.

You can supply an extra argument to the stopat command, to specifiy a line number.

You can see the line numbers by issuing the showstat command, eg. showstat(genpellsolve) .

It's hardly suprising that the debugger isn't being effective in your example, given that the DEBUG() is after all the computations in the genpellsolve procedure except for the return. So the debugger won't intervene until the return line, with the way you've written it.

debugger_basics.mw

Do you mean this?

Download physicsdiff.mw

There are lots of slight variations that can produce this. Here is another below, which happens to not require using op to yank out the first frame of the spacecurve animation.

You could also generate a 3D line-segment using just two end-points, rather than a spacecurve with its default number of data points.

You might be interested to know that the thickness=2 option you had in your second call to animate is eventually affecting most of the structures. It clobbers the thickness=3 you had on the spacecurve, and even affects the plane. This is because you have it as an option to the animate command itself, rather than as one of the arguments to the plotting command (which appear inside the brackets, the second argument passed to animate).

You could also use spacecurve instead of plot3d for the helix, and then pick up the color=red option which you seemed to be wanting(?) there. This also makes a smaller memory footprint. The "size" of animation structures in Maple can often affect GUI, or export, time performance, so I thought you might like to know.

restart;
with(VectorCalculus): with(Student[LinearAlgebra]): with(plots):

v[i] := 145000: thetabn := (1/8)*Pi: thetavn := (1/6)*Pi: k := 10: omegac := .5:
lrange := 6*Pi: v[b] := cos(2*thetabn)/cos(thetabn):
v[g] := sin(2*thetabn)/cos(thetabn): n := `<,>`(k*cos(thetabn), k*sin(thetabn), 0):
vr := [v[b]*t, v[g]*sin(omegac*t)/omegac, v[g]*cos(omegac*t)/omegac]:
lambda := v[i]*cos(thetavn)/cos(thetabn):

pt := [t, 0, v[g]/omegac]:
pline := A -> display(plottools:-line(eval(pt,t=lrange), eval(pt,t=A),
                      thickness = 3)):

shockplot := PlanePlot(n, caption = "",
                       planeoptions = [colour = blue, transparency = .5],
                       normaloptions = [shape = cylindrical_arrow, colour = red]):
t1 := textplot3d([k*cos(thetabn), k*sin(thetabn), 0, 'n'], align = above):
B := animate(pline, [A], A = lrange .. 0, paraminfo = false,
             background = display(shockplot, t1)):
C := animate(spacecurve, [[v[b]*t, v[g]*sin(omegac*t)/omegac,
                           v[g]*cos(omegac*t)/omegac],
                          t = 0 .. x, colour = red, thickness = 2],
             x = 0 .. lrange, paraminfo = false, labels = [" ", zeta, xi],
             background = display(shockplot, t1, pline(0))):

display([B, C], insequence,
        axes=none, orientation=[-158,-17,0], scaling=constrained);

There appear to be infinitely many solutions in the set determined just by {c11=-1. c9,c3=-1.,c5=-1. c7,omega=0} .

So, as long as you make c11, c3, c5, and omega respect that, then you could make the remaining variables take on whatever scalar values you want.

Download solve_ac.mw

Using Maple 18 (like you),

Download ask_ac.mw

It's possible that `evalf/int/control` is not falling back gracefully, after encountering the overflow.

It might even be fun(?) to use the URL package to look up the current conversion rate and amend the AUD unit's conversion formula.

Download CURRENCY_AUD.mw

You can left-align each of a sequence of Typesetting:-mtr rows, and then put them inside a call to Typesetting:-mtable .

(This is similar to how Matrices are typeset, but without the braces.)

I haven't bothered to remove your Tsprintf procedure, now unused. And I haven't bothered to make the conditional branches more streamlined (it shouldn't be necessary to make it all explicit like that).

You could also have various different procedures that each returned their own Typesetting:-mtr call (eg. for different kinds of question). You wouldn't be able to print them, until you could wrapped all such results in a single Typesetting:-mtable call.

Download Goi_mapleprime_ac.mw

You can easily generate a sequence of such things.

So, you could use such a generated sequence in the arguments of the Minimize command.

seq(x[i]=1..2, i=1..5);

    x[1] = 1 .. 2, x[2] = 1 .. 2, x[3] = 1 .. 2, x[4] = 1 .. 2, x[5] = 1 .. 2

op(map(v->v=1..2, [W, a, x, y]));

             W = 1 .. 2, a = 1 .. 2, x = 1 .. 2, y = 1 .. 2

expr := a^2+sin(b*Pi+c):

indets(expr, And(name,Non(constant)));

                          {a, b, c}

op(map(v->v=1..2, indets(expr, And(name,Non(constant)))));

               a = 1 .. 2, b = 1 .. 2, c = 1 .. 2