Did you call fclose or fflush (or restart)?

If not, then buffered results may not yet be flushed to the file.

Another possibility is that currentdir() is not what you expecting. That's a Maple command.

You could use,

    1+ilog2(n)

Eg,

    1+ilog2(22);

              5

For base 3 you might use the following,

   nops(convert(n,base,3));

and you might be able to use the following for positive integers,

   1+trunc(log[3](Float(n,0)))

Test, to make sure I haven't made mistakes.

For some reason the Sliders don't appear when the worksheet is inlined in this discussion forum. But they're there in the .mw file. You need to execute the definition of F, for it to work.

You should easily be able to add a textplot at the end-point of the 4th arrow.

Download expl_rgb.mw

And here is a version that creates it in a new Tab in the GUI (new worksheet). This should subsequently run-standalone, as the definition of procedure F gets put into the Startup Region of that sheet.

Download expl_rgb_mkalone.mw

You might call Optimization:-Maximize on a range restricted to close to a peak. This can be performed on a simplification of abs(q) that is real-valued with less imaginary roundoff noise (artefact).

For example, using Maple 18.02,

Download p3dopt.mw

Here is one way, using Maple 17.

In modern Maple there are more ways to get similar effects.

I could have used just plots:-surfdata to get the surface. But coloring that flexibly would be more complicated. And there are a few irritations with using plots:-listdensityplot here.

So instead I construct an interpolating procedure F, which I use for the various pieces.

Download MAXR_surfcontdat.mw

The index option is not available to the max command in Maple 17. You could see that by reading its Help page in your version.

As a simple (but less efficient) alternative, you could try using,

    ind[k] := ListTools:-Search(max(abs(Y[k])), Y[k]);

instead of your,

   ind[k] := max[index](abs(Y[k]));

Note that there are other problems with the code. You assign to lowercase tol but then try and compare something against all-caps TOL. which has no assigned numeric value. The code tries to use yp, but that is unassigned. And so on.

Here is one way.

The Table looks nicer in actual Maple.

You could suppress the display of the Matrix (ending the line containing the statement that creates it with a full colon), if you're also going to Tabulate it.

The plot was just for fun. (You could also make a dual-axis plot with, say, height on the left vertical axis and velocity on the right vertical axis.) The plot could also be animated.

thva.mw

You can store multiple procedures (as well as modules that export procedures) in a special kind of file called a Maple Library Archive. Such a file has .mla as its filename extension.

I suggest that you start by reading the Help pages for the LibraryTools package's documentation.

You could start by calling LibraryTools:-Create to make a .mla file.

Then you could call LibraryTools:-Save to store your various procedures within it. I strongly suggest always using the calling sequence in which you supply the location of the file explicitly (ie. without using savelibname).

Once you have stored a procedure within the personal .mla file you can use it from any other worksheet/document/session as long a its location is one of the items in the path assigned to libname.

For example, suppose that you'd stored procedure MyProc inside a .mla file at location,
    C:/Users/Acer/mystuff/MyArchive.mla
In that case you could augment libname with the Maple command,
   libname := C:/Users/Acer/mystuff/MyArchive.mla, libname;
One way to make that libname adjustment automatic is to put that command inside a personal initialization file.

An alternate way to make that libname adjustment happen automatically upon launch/restart is to use a special kind of location. For example, if my MS-Windows username were "Acer" then the following is such a special location,
   C:/Users/Acer/maple/MyPackage/lib/MyPackage.mla
where "MyPackage" could be some name of my choosing. I'd use this when calling the LibraryTools commands mentioned. Then my stored procedures could be used immediately and directly in any new Maple session.

You might also consider encapsulating a collection of related procedures inside a package, which is a special kind of module. You can read some documentation on this in Chapter 11 of the Programming Guide. That chapter also has a subsection on using LibraryTools, like I described above.

The URLs I give are links to the on-line version of the documentation, usually corresponding to the current version of Maple. You can also access these Help pages -- offline and specific to your version -- from within Maple itself.

In the example you mention, the solving was invoked by using the context-sensitive menu of operations in the left panel of the GUI.

That very fact is stated right there at the bottom of your example.

I suggest you read the corresponding Help pages (documentation). I've used a URL link above so that you can get to the on-line version of a relevent Help page.

The following example will produce a list of lists.

Each inner list has three components, for x,y, and z.

de := plot3d(y*sin(x), x = 0 .. 2*Pi, y = -2 .. 2):
temp := plottools:-transform((x,y,z)->[x,y,z])(de):
convert(plottools:-getdata(temp)[3],listlist);

As Preben has shown, your Question's second integral can be done directly in Maple 2022.2, and then further simplified. But I was unable to get that symbolic integral to compute directly in Maple 2022.1, nor any version of Maple 2021.

And your response to him mentioned only Maple 2021 in the context of that example. You then mentioned both Maple 2021 and Maple 2022 for the followup Statistics example. I would guess that means you have Maple 2022, but I'm not 100% sure.

So, for fun, here's how it can also be done in Maple 2021.2 (and onwards),

Download mmcdara_int_2021.mw

Fwiw, your original Question's second integration example can also be forced in Maple 2015.2, by converting to Heaviside, veiling those, changing variables, computing value symbolic, and then reverting to piecewise. That kludgy approach produces some undefined discontinuities at a couple of points, which I know you don't like.  mmcdara_int_2015.mw

Those techniques involving change of variables don't seem to help in older versions for your followup Statistics example, which has an integral of a product of two piecewise, one with conditions on z/t and one on just z. This gets messed up in older versions (similar to how previous versions go awry on the two original integrals, I believe) and can erroneously produce just zero.

But perhaps you do have Maple 2022.2, which gets that followup symbolic integral as well. Or perhaps you'd be satisfied with much faster numeric integrations, as I mentioned elsewhere.

1) The forward slash dates from before modules. It's presence in Library procedure names is usually just a reflection of the directories (and subdirectories) in which the source files were stored on a Unix system. That was a convenient convention for naming internal routines within, say, old table-based packages.

Mostly the forward slash doesn't give special functionality to names. One exception is the case of the extension mechanism for kernel builtins, eg.   `print/foo` as a way of naming a procedure that would be used automatically for printing unvaluated function calls foo(...).

2) The left ticks are needed to let the parser distinguish between, say, the fraction foo/bar and the name `foo/bar`. Single left-ticks (aka name quotes) allow you to have names with nonalphanumeric characters, etc.

In contrast, the colon-dash :- is a special syntax for referring to module members. If you wrap that in name quotes then the parser sees it as just a name that happens to have some special characters in it, ie. not as a module member reference.

So these cases are actually consistent. A pair of wrapped left ticks veils the special syntactic meaning of forward slash / (ie. division), just as it would veil the special syntactic meaning of colondash :- (ie. module membership).

3) A module can be "appliable", in the sense that its name can be applied directly to arguments. For example fsolve is now a module, yet you can call  fsolve(cos(x)) .  That actually invokes 

     fsolve:-ModuleApply

on the arguments.

4) The showstat command is for rendering a display of a procedure's structure and body, including line numbers. You can also call `print` on a procedure.

You can also print (or make a string from) parts of a module. See the Help for a description of the various operands of a module. 

Note that showstat was not designed for modules and it's not clear how precisely it would display such, or why it ought to.

Note that you can call,

    showstat(fsolve::ModuleApply)

if kernelopts(opaquemodules) is `false`, and that were `true` you could use :- instead of :: .

[edit] IIRC you can also call `printf` with "%P" to specify the format, and get a plaintext, indented display of a procedure  eg.

   printf("%P",
              eval(fsolve:-ModuleApply));

The last time I checked  I could not do the same in one shot for a module. (That's inconvenient for me as module bodies can exceed the line length limit if printed after converting to unbroken string. I'd rather have nicer text pretty-printing than crude backslash linebreaks.)

If you have already executed this:

with(GroupTheory): with(DocumentTools):
lis := SearchSmallGroups('order' = 10 .. 100, 'soluble'):
S := seq(DrawSubgroupLattice(SmallGroup(g), 'highlight' = CompositionSeries(SmallGroup(g))), g in lis[10 .. 20]):

then you could do something like the following,

Tabulate(Matrix(4, 3, [S])):

You can force the issue here by using the symbolic option of simplify and combine. Or you can use an assumption.

See the Help for some description of that symbolic option, here and here.

Sometimes the solve command will produce a "simplified" form (half your goal here).

There is a large set (nonzero measure in the RxR space of m and c) where the expression sqrt(m*c)/m and sqrt(c/m) are not equal. Hence it would hardly be an improvement if those two commands treated these two forms as equivalent, by default. I'd agree that it would be an improvement if the context-menu (context-panel) offered the choice,
   combine(..., symbolic)

Download symbolic.mw

I'm not sure that I fully understand what you mean by "improve" or "best".

You could use the mathfunc type. You could restrict that to not include the elementary functions.

In such a way you could decide up front what you want to accept as "elementary". And presumably that internal list of special functions is updated if something gets added to Maple's stock.

For example, (and this could be tweaked):

Download specf.mw