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.

Download ent_seq.mw

Those are just Maple names which line-print like the unicode decimal codes and pretty-print (2D Output) like the typeset lowercase Greek letters.

For example, the Maple name `α` gets typeset in 2D Output as the symbol for the Greek letter alpha.

You don't need to wrap in any MathML style markup (eg. mo(...), mi(...) ) for that basic effect.

ps. It's not entirely clear exactly what you wanted to accomplish. Perhaps you're trying to do something different. Are you looking for a way to programmatically generate the literal names alpha, beta,...,omega as written in the Latin alphabet?

Download type_chk_ex.mw

That is the behavior of evalb, which is the default mechanism for if..then conditional testing. (That Help page describes the kinds of equivalence it tests.)

For such polynomial comparison you have a few alternatives -- to get a mathematical equivalence test of the kind needed here -- including expanding (or putting the difference into normal form) before comparing, or using is, or testeq,

Download evalb_et_alia.mw

In general some such mathematical tests for equivalence are potentially more expensive than others. The user gets to decide which might be used.

In Maple 2021 and later the form you want is produced directly. (You haven't told us what older version you are using.)

Here are three different ways to get that integration result.

Download int_old_ex.mw

ps. In Maple 2021 and later the result,
   1/3*x^6*cos(x^6)+1/6*(x^12-2)*sin(x^6)
is produced by default (no method) and by method=risch, and a close trig form by method=meijerg. In Maple 2020 and earlier the method option was not supported for indefinite integration (hence my 3rd workaround above).

You appear to have made two kinds of mistake.

The first is that it looks like you've forgotten to put either an explicit multiplication symbol or a space (to denote multiplication implicitly) between the name a and the left open-parenthesis.

The result is that you've entered a(x-a) which is a function call of a (some as yet undefined operator...). You haven't used any syntax for a*(x-a) a product of a and x-a.

The second mistake is that you subtracted instead of added.

Download 2d_mul_ex.mw

There are several things you can do with that in Maple. For example,

Download sum_ex.mw

ps. I converted your Post into a Question.

The following code shows how you can programmatically turn equations into such scalar expressions, or vice versa.

It also let's you do that if you have a mix of both. But it can also work if you have just all one type, or the other.

It's a simple task, so the code to handle it ought to be simple. I've tried to make this code straightforward, so that a Maple beginner could learn a bit from it. I deliberately didn't make it as super terse as possible.

Download type_equals.mw

The following is a glossed-over over-simplification.

Personal computers that one could purchase today have CPUs with associated hardware (circuits) specialized for the task of performing arithmetic on floating-point numbers stored/encoded in a mere 64 bits (double precision) or 32 bits (single precision) of memory.

Such so-called "hardware floats" are restricted in range, both in terms of the number of decimal places of the mantissa (roughly 15 decimal digits for double precision) and exponent.

If your machine's Operating System is made aware via some program (eg. compiled C, Maple, etc) of such floats in memory then it can make calls to have the relevant hardware chip perform such "direct" arithmetic operations. The hardware chips of personal computers made today can do billions of such operations per second (provided the program and OS can supply them that fast).

The essence of this speed is due to the numbers being stored in (64, or 32) bits that are encoded in a form that the hardware arithmetic unit understands directly, and the fact that the range in which these hardware floats exist is quite restricted. The restricted possible range of these floats allows for adequately accurate yet very fast dedicated circuitry or algorithms to be possible.

But Maple can also handle floating-point numbers from a much wider range -- with many more possible decimal digits, and much smaller/greater exponent. The floating-point arithmetic on such so-called "software float" numbers is emulated by the software program, and the numbers are stored in another kind of specialized encoding, ie. a more involved, higher level, dedicated data structure. These operations are considerably slower than those so-called hardware float operations mentioned earlier. Such software floats also require additional overhead (eg. memory-management).

Maple is an interpreted language, and the Maple program has a core interpreter that performs symbolic computations as well as performs/dispatches integer and software-float computations. Maple also has an alternate interpreter, available as the evalhf command, which can do float arithmetic more quickly because it uses the very compact hardware float representation and the mentioned low-level computations that the machine's chips can perform directly. Sometimes the relative performance benefit is as high as a factor of 15-30. The evalhf benefit is mostly restricted to a relatively smaller assortment of numeric operations, however.

Throughout the above, I've just written "arithmetic". But the situation is similar for elementary operations such as sqrt, sin, exp, etc. Either the Operating System's runtime math library or the hardware chipset offers dedicated mechanisms to compute those operations accurately and quickly for hardware floats. Computing those for arbitrary precision software floats is computationally more expensive.

There are a couple of other ways to get some speed benefits of hardware float computation, from within Maple. Eg. the Compiler, and option hfloat on a procedure. (See also these two articles [1], [2], now old.)