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

Another approach is to store the loop index value k and the value of a in a table, and then turn that into a Matrix as a later step.

That allows you to easily handle the situation where some entries are omitted (because, say, they fail some conditional test). You can still have easy access to the accepted indices and values, and plot just those.

Here's an example. There are other ways to accomplish the same thing, some of which are terser, but I've tried to keep it understandable.

Download table_aug_Matrix.mw

I'm not sure how you're expecting the omega(t) values to be used. But this may be a start, or give you some ideas.

The key part here is that I'm using my earlier idea (see Reply above) of using a custom procedure F which can generate each frame.

Once you have such a procedure it is easier to test. You can call it with different arguments and see how it looks. When satisfied you can easily animate it.

[edit] I have adjusted the shape that I plotted with my method.

Download how_rot_ac.mw

By calling parse you turn the strings back into Maple expressions, so naturally when you print them as normal output then you get the same effect as for the original, ie. sequences are pretty-printed with spaces after the commas, whether they are in a list or just as a sequence.

If you want to line-print strings, without the quotation marks appearing, then you could use printf (on the strings, with %s format) instead of print or lprint. Note that conversion to strings might be unnecessary -- your particular goal is still unclear.

If you want to export the entries to an external file then you could use the ExportMatrix command, eg.,
    ExportMatrix("myfile.csv", Matrix([ans1]));
That produces a file named myfile.csv with three lines, each with the entries separated by commas and without spaces. That command has some additional flexibility along those aspects.

What are you actually trying to accomplish with sequences of numbers displayed without spaces after the commas? Are you trying to export it to an external file, for some other software? Or are you going to copy&paste from what is displayed on your Maple GUI?

It is a very common phenomenon on this forum for people to have some task they want to solve, then ask about only part of their approach to solving it, without describing the actual underlying goal or full process that they want. This usually leads to guesswork and unnecessary and inefficient back-and-forth.

In the Maple programming language (1D plaintext, also known as Maple Notation) the word for infinity is:

   infinity

That entry box in the popup is a Maplets TextField, and it expects plaintext Maple Notation.

This seems to be a consequence of the result from DiagonalMatrix having shape=diagonal and storage=diagonal.

A workaround is to force off the compact shape/storage (see two ways, below).

I will submit a bug report.

Download Starnge_ac.mw

Is you lprint the SearchSet you can see that its float values are not what appears in the 2D Input.

I don't know how you managed to get that effect (cut&paste, something with numeric formatting?).

You could re-enter it manually.

But you may still be faced by discrepencies if you expect floats to be matched in the case that they have differing numbers of trailing zeroes.

It might be better if you described precisely what kind of matching you are after, ie. float comparisons to a fixed precision, etc. It may be that verify it a more suitable tool for the comparison, but that depends on what comparison you are after.

Also, you asked about why some sorting occurs. That's how Maple acts with sets of floats. If you don't want them sorted then you could use lists of Vectors instead.

Download Binary_search_ac.mw

An explicitl description of what you're actually trying to accomplish would be a good start to getting best advice.

It would be more helpful and direct if you were to supply the complete example when first submitting the Question.

Hopefully this uses the dsolve solution to produce your line animation in a satisfactory manner.

Download anim_ac.mw

You have b assigned as a Matrix. That's your basic mistake, since you were only indexing into it as b[i], as if it had just one dimension.

Try making it b as a Vector instead, ie,

   b := Vector(3, [-1, 7, -7]);

Below, I have removed also the loading of the VectorCalculus package since that rebinds the Vector command which is hardly useful here. I changed the call of Norm to be explicitly a call to LinearAlgebra:-Norm.

I suggest that you check that it works as you intended.

Download code_zeineb_ac.mw