The op command can extract the operands of a radical.

In particular, you can use op(1, ee)  where ee evaluates to the radical. And you can map that across a set or a list of radicals.

You can extract all subexpressions of type radical from an expression using the indets command. That returns them as a set.

For example,

expr := sin(sqrt(b^2-4*a*c)) + sqrt(bar):

map[2](op,1,indets(expr,radical));

                            2
            {bar, -4 a c + b }

# Alternatively, applying the op command elementwise
# over the set.
op~(1,indets(expr,radical));

                            2
            {bar, -4 a c + b }

You can subsequently create new expressions from those operands, such as inequalities, etc.

I'm not sure that I understand what you ask about a "Matrix".

But ColorTools:-Gradient can produce a list across a range of colors in a colorspace. (It includes the endpoints, so number can be supplied as two less than the target.)

Your can choose between various color spaces. You can experiment, if say you wish to avoid a gray area, etc. The "Luv" color space may provide a result where a linear transition is more visually even than that from the "RGB" default. (RGB is more even in terms of what your monitor emits, but Luv and Lab may be more even in terms of what the average eye perceives.)

note. The various Gradient results at the botton look different in the actual Maple GUI than they do inlined here.

Download colorgradient.mw

Conditionals are tested (under if..then, as a Boolean) using evalb as the basic mechanism. That Help page for evalb states,

    An evalb call using <, <=, >, or >= returns evaluated only with arguments
    of type extended_numeric, complex, or string.

That Help page also contains an example involving an exact radical, where it uses the is and the evalf commands instead.

if is(2+89^(1/2)>0) then
   print("yes");
else
   print("no");
end if;

              "yes"

The eval command provides the functionality to evaluate an expression using the equations.

You can also use it to evaluate one or more names (on the LHS of those equations) to pick off the values. (This is also more robust when the equations are in sets, as it doesn't depend on their ordinal poisition.)

Sometimes this use of eval is call 2-argument eval.

I also show how you can utilize eval in this manner, without having to assign the names to new temp variables. You can of course experiment.

Check the results, as I'm not sure what roles all the names take throughout. I may have used it in a way other than you intended.

new_filter_solution_1_ac.mw

note. To express, say, 2*10.0^(-12) you could type in 2e-12 without space before the e.

note. You have large and small numeric quantities around. You might wish to use a higher working precision to guard against roundoff error. That can be done using evalf[N] or higher Digits. I'm not sure it is needed, though.

As mentioned, the with command won't work within a procedure. But orthopoly isn't needed here anyway.

You should not unprotect gamma. But you don't need to touch the global name gamma anyway (as you can use it as a procedure parameter or even a local).

You should not unprotect Psi. Instead you can declare a top-level local of the same name, in your Maple 2020.

The operators that your code constructs inside functionA and functionB contain references to the global K. Yet functionA and functionB bother to set up their local K (using passed k). This is a muddle. By using the unapply command your functionA and functionB can construct the operators with the precomputed K value. Then you don't need to recompute K at the level from which you call functionA and functionB in examples.

There were a few other problematic situations possible with the other variables in the formulas, due to not utilizing unapply.

Your functionA and functionB were using the global name x without protection against it being assigned. [edit] The same goes for n and m. So all three can be better declared as locals of functionA and functionB.

Your formulas used to construct the w operator don't depend upon n, so I removed that parameter from its construction.

Your example code used many full colons, supressing output and hiding some of the issues.

You don't need to save/load this module to a .mla Library archive, just to test its basics.

You should stress-test this revision.

Download ML_code_ac.mw

The global name gamma has a special meaning in Maple, and refers to a particular real constant. (That's why you cannot assign a new value to it. The name is protected.)

The error message from the implicitplot command is due to your use of the global name of the constant gamma on the left hand side of R.

The simplest course of action in your Maple 11 is to use another name instead.

For your first question, it seems to me you are asking about the functionality provided by the unapply command.

And for your second question, a DataFrame might possibly serve.

See a link to the attachment below.

unapply_df.mw

The first step can be done using the rationalize command.

The second step can be done by rewriting the given substitution equation.

Download Resonant_xformer_ac.mw

Here's another variant, using InertForm with the inert operators for the divisions and additions, and with the active operator for multiplications. The active multiplications are implicitly displayed in output (ie. the multiplication symbol suppressed).

Download SérieAléaEqFractionnaires1_ac.mw

Your document had the same operations done multiple times. You don't have to load the InertForm package (utilizing the with command). You certainly don't have to call with multiple times.

You could turn the example generator into a procedure, to make it all cleaner.

You could also use Embedded Components, with each new example replaing the old one. (It could be as simple, or as fancy, as you choose.)

Your document also made me think of the Quiz package.

Download sqrt_evalc.mw

How do you feel about t=0 ?

The odeplot command makes it easy to specify what goes on which axis.

Download odeplot_v.mw

A small modification of your code gets you the following. Is it something like your goal?

You could easily make it a procedure.

Download adjoint.mw

Download rad_combine.mw

I have not utilized the cosine property cos(-z)=cos(z) however.

You can represent this operation with a call to %.  as an inert noncommutative multiplicaion.

The dot symbol renders in gray by default, but you can also use InertForm:-Display to render it in black.

The value command is one mechanism (of several) that turns it into an active computation.

Download inertmatmul.mw

[edit] Changed to an infix call, see comments below.