You could pass solve the option real along with the option parametric, rather than take those separate solving steps.

You could contrast the effect of then solving for [Q,XC1] versus [XC1,Q]. Note which gets expressed in some inequalities in the solution.

I removed the assignment to Q, and made that unassigned name part of the equation.

Download pi-filter_copy2_ac.mw This worksheet doens't inline well on this site.

If you do prefer performing the extra manual steps (ie. first solving explicitly for XC1, then solving in terms of Q and R1 for the radical arguments to be positive, for each intermediate solution) then it is more robust to pick off the radicals using indets rather than the problem-dependent approach of picking of subexpressions by position.

Is this the kind of thing you want?

Download sort_ac.mw

When you write xy without any multiplication symbol (or even a space in 2D input mode) then it just means the single name xy and has nothing to do with either name x or name y.

Also, for correctness and clarity use y(x) instead of just y, in a consistent manner.

TEST_CODE_1_ac.mw

Check your results for any remaining issues, naturally. [edit] Ask your followup queries in this same Question thread, please. (I expect you might have some... for this apparent coursework example)

Download plot_removable.mw

You could compare the various different formulations below.

It's not clear which you might find best. You might even prefer to not supply the inequalities within the first argument passed to solve. Checking correctness all round might also be prudent.

Download pi-filter_copy_ac.mw

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