MaplePrimes - answers and comments on Question, How do I get "simplify" to simplify?

Using 1D-input

Preben Alsholm — Wed, 15 Sep 2010 10:40:12 Z

Converting your expression to 1D-input (I never, ever, use anything else) you get the result you presumably want.

T := RL/(j*omega*Cp*(RL-I/(omega*Cp))*(R/(j*omega*C[s]*(R-I/(omega*C[s])))+RL/(j*omega*Cp*(RL-I/(omega*Cp)))));
simplify(T);

#If your variable RL is actually R*L then:
T := R*L/(j*omega*Cp*(R*L-I/(omega*Cp))*(R/(j*omega*C[s]*(R-I/(omega*C[s])))+R*L/(j*omega*Cp*(R*L-I/(omega*Cp)))));
simplify(T);

What happens in 2D I don't care to speculate about.

atomic identifiers

pagan — Sat, 18 Sep 2010 01:06:13 Z

The problem is that some of the subexpressions in your big expression T are actually atomic identifiers.

An atomic identifier is a Maple name, formed of single left-quotes between which lies magic stuff. Maple's Standard GUI knows how to prettyprint the stuff as if it were some 2D Math. But underneath the whole subobject (whether it be a complicated fraction or formula or whatever) is just a single name.

I'd like to know how those subexpressions became atomic identifiers. If it happened automatically, without a deliberate action by you, then it may be a bug (because the imaginaryunit was set?).

For example, your expression T has what looks like the following subexpression in it.

But that subexpression is not what it seems. In fact, the object T contains just a fancy name which gets type-set as that. Underneath, the subexpression is actually the name

        `#mi("R")`/(j*omega*`#msub(mi("C"),mi("s"))`)

As someone else mentioned, you can try using the right-click context-menus to convert all of T at once from 2D Math to 1D Maple notation. That is, select the input T (not the output), right-click and make the context-menu choice 2D Math -> Convert To -> 1D Math Input. That's probably easiest, given the fact that you've already entered it in 2D Math.

Alternatively, you could try and replace each of the atomic identifier subexpressions inside T, using repeated application of set of similar context-menu actions. But to do so with the mouse you'd first have to find which subexpressions in particular are atomic identifiers. That is to say, how would you know how much to select with the mouse, before right-clicking? You could lprint(T), and try and interpret it visually, but it's a little messy. Or you could try and remove all atomic identifiers with a program.

> FromAtomic := proc(expr)
> local temp, origkom;
>   origkom := kernelopts(opaquemodules=false);
>   try
>     if assigned(Typesetting:-SemanticTable[convert(expr,string)]) then
>       temp := Typesetting:-SemanticTable[convert(expr,string)];
>       temp:=op(-1,Typesetting:-Parse(temp));
>     end if;
>   catch:
>   finally
>     kernelopts(opaquemodules=origkom);
>   end try;
>   if assigned(temp) then
>     eval(temp);
>   else
>     expr;
>   end if;
> end proc:

> subsindets(T,name,FromAtomic);
           //         /         I    \ /
            |omega Cp |R L - --------| |
  - (I R L) |         \      omega Cp/ |
            |                          |
            \                          \
                I R                         I R L          \\
  - --------------------------- - -------------------------||
               /        I     \            /         I    \||
    omega C[s] |R - ----------|   omega Cp |R L - --------|||
               \    omega C[s]/            \      omega Cp///

> simplify(%);

                      (-R omega C[s] + I) L         
           - ---------------------------------------
             R L omega Cp - I + L R omega C[s] - I L

Anyone interested in "robustifying" that `FromAtomic` routine might have a peek at Typesetting:-RemoveAtomic. But you can't just utilize that routine as is, since it has the here unwanted side-effect of not just returning the non-atomic expression but also of undesirably unassigning the associated entry from the Typesetting:-SemanticTable.

why dont you simply enter you task into a classical sheet?

Axel Vogt — Sat, 18 Sep 2010 21:16:44 Z

why dont you simply enter you task into a classical sheet and upload that?

for me it unclear what you want to have entered and that should be prior to a pretty appearance

Solution to my problem

Ratch — Mon, 20 Sep 2010 08:29:11 Z

To All,

I think I found the solution to my problem. I use just plain subscripts, not atomic subscripts. As the example shows, this can be a problem if the base variable is defined before the subscripted variable is. But if one defines a variable with a subscript of a space, it looks just like the base variable does, and does not hang up when part of a complicated expression. See the attached worksheet.

Ratch

Simplify_Problem_Thr.mw

Possibly a 2D "bug"

longrob — Wed, 15 Sep 2010 16:40:51 Z

To make Preben's point even clearer, there is no need to even re-type the input in 1D

I copied the 2D output from your worksheet into a Maple 13 classic (1D) worksheet. This comes along with all the hard-to-read 2D formatting thus

T := `#mfrac(mi("RL"),mrow(mi("j"),mo("⋅"),mi("ω",fontstyle = "normal"),mo("⋅"),mi("Cp")),linethickness = "1")`/((RL+1/(j*omega*Cp))*(`#mfrac(mi("R"),mrow(mi("j"),mo("⋅"),mi("ω",fontstyle = "normal"),mo("⋅"),msub(mi("C"),mi("s"))),linethickness = "1")`/(R+1/(j*omega*`#msub(mi("C"),mi("s"))`))+`#mfrac(mi("RL"),mrow(mi("j"),mo("⋅"),mi("ω",fontstyle = "normal"),mo("⋅"),mi("Cp")),linethickness = "1")`/(RL+1/(j*omega*Cp))));

But if you then copy the output of this to the next line, you get this

T := RL/(j*omega*Cp*(RL+1/(j*omega*Cp))*(R/(j*omega*C[s]*(R+1/(j*omega*C[s])))+RL/(j*omega*Cp*(RL+1/(j*omega*Cp)))));

which then simplifies to

(R*j*omega*C[s]+1)*RL/(R*RL*j*omega*Cp+R+RL*R*j*omega*C[s]+RL)

I also never use anything else than 1D input, because I find 2D hard to deal with and I learned using 1D, so I also don't know why 2D doesn't work.

Thanks to all for your answers. I will

Ratch — Wed, 15 Sep 2010 20:34:48 Z

Thanks to all for your answers. I will try it, but 2D really should ought work after 13 levels of development. And such a simple reduction too. Ratch