This is what your commands perform, using assignments instead of % for the referencing.

Note that your second use of % is referring to what is assigned below to T. Your second use of % is not referencing the same as your first use of % (which is the result assigned to S below).

Download indets_q.mw

What are you actually trying to query, via indets? Subexpressions (or instead perhaps only things of some specific type, such as names only?) in the solve result?

[edit, upon consideration that you might be asking about another aspect.]

Or perhaps you're asking about what counts as an indeterminate/subexpression? The result of indets(f(_Z),_Z) includes plain name _Z, the argument of f. But the common dummy _Z of RootOf is not returned, as a specially treated consideration.

Download indets_qZ.mw

The dummy _Z of RootOf is special in other ways. The dummy index name of sum/Int/etc is not changed or specially "uniquified", but RootOf turns such into _Z.

Download RootOf_note.mw

In a way it boils down to what developers have deemed useful. A query of whether an expression contains any RootOf ( eg, has,hastype or indets(...,RootOf) ) will be a test for the presence of its dummy name _Z. In contrast a query about plain name _Z used in some other context, eg. ln(_Z) alone, doesn't benefit from that implication.

But since the dummy name in sum/int/etc is user-defined and arbitrary then it make a bit more sense to report on it.

Download indets_q3.mw

You've set up the define_external call so that you can pass in matrix `c` as one of the arguments (and thus act on that inplace). So no matrix actually gets returned. This is reflected in the Fortran code shown.

So you might look in the documentation for how to specify a NULL return (or something ignorable, possibly integer[4]).

Here is one simple way to get interleaved text and 2D Math for output (without the quotes of the strings, and with the strings in upright roman rather than italices, etc).

This site uses a very old maplenet which renders the units in double-braces. In the actual modern Maple GUI those units get rendered as usual.

Download some_TS.mw

Try that instead as,

textplot([[coordinates(A)[], "A"], [coordinates(B)[], "B"], [coordinates(C)[], "C"]],
         align = {above, right});

Try right-clicking inside the Table, and then selecting Table->Properties in the popup. (Or open the GUI's right context-panel, and left-click to place the mouse focus in the Table.) Then change the "Page break" property to, say, "Allow between rows".

Then try exporting of print-to-PDF.

(If you actually have a Table with nested Tables inside each cell, say, then you need to be careful to position the mouse-pointer some place inside the outermost Table but not within any inner Table, so that you actually adjust the properties of the Table that has all the rows...)

The programmatic Table constructor of the DocumentTools:-Layout package allows pagebreak to be specified as an option. But that option is not offered by the Tabulate command, which utilizes that lower-level constructor. I'll submit a software-change-request that either the default be changed in Tabulate or that it offers the option itself.

An example of a programmatic way to get such an effect, without the need to right-click:

M:=Matrix(77,2,(i,j)->i*j):

xml:=subsindets(DocumentTools:-Tabulate(M,'output'=':-XML'),
                "pagebreak"="none",()->"pagebreak"="row"):
str:=DocumentTools:-ContentToString(
       DocumentTools:-Layout:-Worksheet(
         DocumentTools:-Layout:-Group(xml))):

## If you want the table alone in a new GUI tab
#Worksheet:-Display(str);

## If you want it embedded in this same worksheet
DocumentTools:-InsertContent(str):

The above code also works for me (page-breaking in PDF export/print) if M is a DataFrame instead of a Matrix.

You could use the Explore command for this.

For example (and without going all-out for optimizing it),

Explore_anim_ex.mw

Your followup example can be done as follows:

Download Jamet_1.mw

Yes, you can construct a reusable procedure from your expression involving the functions in the dsolve solution.

I cannot tell whether you want epsilon and omega*t (as you've written in your Question text) or varepsilon and `ωt` as you've used in the parameters list in your worksheet. I guess that it's the latter, but I've set it up below so that you can assign what you want to expr.

Download New_2_ac.mw

The Color Collections Help-page explains quite a bit of the purposes and nature of the various stock color palettes.

I don't know of any programmatic mechanism (ie. GUI streamcall) that would cause the GUI to reexecute all inputs in usual Execution Groups and Document Blocks.

The "action code" of Sliders can be used to update other Embedded Components (or do file i/o, escaped system calls, etc), but as far as I know it cannot directly affect normal input/output of the worksheet.

It is possible for the action code to replace some previously embedded content (lock, stock, and barrel). And that includes re-embedding some whole new .mw there. However I also don't know of any mechanism that would programmatically execute&save an external .mw file. Even if such a kludge worked it wouldn't really be the same as the normal input/ouput areas.

Programmatic reconstruction of the entrie .mw worksheet from scratch would be a great deal of work, and opening such in a separate new GUI tab for each Slider change sounds awkward and not useful. So, I'm afraid that I'm out of ideas here.

These results are in a reasonably simple form.
 

Download RO_ex.mw

It seems to me that you want/need a mechanism to force your shootNL procedure to return either uN(bV) or vN(bV). Your original attempt had shootNL return the expreszsion-sequence of both values.

Your attempt at using fsolve was running into additional problems because the shootNL calls were being prematurely evaluated at the symbolic names sU and sV.

Here's a quick fix to some of those problems. But I don't see any root (of both u(bV) and v(bV)) in your given ranges 0.5..1 for parameters sU and sV.

fsolveProblem_ac.mw

ps. I didn't bother to make this more efficient (eg. by using the dsolve/numeric parameters option and functionality). First you should figure out whether it's doing what you expect.

If one examines the complexplot3d internal code with showstat then one can see that extra options are passed along to plot3d, via _rest . This allows one to overrride the default color procedure when calling complexplot3d.

Using the operator-form calling sequence with the complexplot3d command below I'll show an example that forces (via argument) an effect similar to the default, as well as another example forcing abs(z) for coloring.

Note that the procedure I'm using for the color option below has two parameters, just as does (?plot3d,colorfunc) the underlying plot3d command that gets called to do the actual construction. The complexplot3d command is like a convenient front-end, allowing the real and imaginary plotting variables to be bundled and passed together for both its expression/operator and its ranges. But we can deal with the color option by handling the real and imaginary components unbundled.

Download complexplot3d_ex.mw

Download complexplot3d_ex2.mw

There are several ways to supply arbitrary color functions.  See ?plot3d,colorfunc 

Instead of using command complexplot3d one could also build the desired plotting structure by using just plot3d with something like z=re+im*I for an expression-form calling sequence, with the two plotting variables re and im.

Here too one doesn't have to use simply,
   color=argument(re+I*im)
but instead one can adjust the formula as desired. Below I merely mimic the default effect.

plot3d_cplx.mw

I am guessing that you want a stand-alone term xi = xi^1 to become H(1)*xi.

Let me know if I've guessed that wrongly.

Download repl_ex.mw

Since Maple 18 the plot3d command accepts an option to directly put an image on a surface (including a sphere, etc).

Prior to that it could be done by manipulating structures. I made an old Post ,and a few others, linked from there, on that general topic. Some of those bits of functionality have found their way into Library commands.