Another very strange result from simplify.  Consider

simplify(a*f(x) + b*f(x) + a*g(x))

Which is what is expected. Now 

expr := a*f(x) + b*f(x) + a*g(x) + 1/(a*f(x) + b*f(x) + a*g(x));
simplify(expr)

gives

why?  I expected (a+b)*f(x) also in the first expression. Compare for reference the same thing in Mathematica where it does them both the same way:

You see it simplified it to (a+b)*f(x)+a*g(x) in both places as expected.

I tried using size option for simplify, but it had no effect.

How can one obtain same result shown above using Maple? And why it does not automatically produce this result?

Maple 2022.2

I give up.

Why 

restart;
the_rule:=A::anything+B::anything=A*B;
applyrule(the_rule,a+b);

returns 0?

I was expecting a*b

No clue from help what I am doing wrong.

Maple 2022.2

trace gives this

restart;
the_rule:=A::anything+B::anything=A*B;
trace(applyrule);
applyrule(the_rule,a+b);


{--> enter applyrule, args = A::anything+B::anything = A*B, a+b
                        answer := a + b

                             i := 

                           i := a + b

                          answer := b

                             i := b

                          answer := 0

                             i := 0

                          answer := 0

I am not sure why it is doing the above still. 

I think I will stick to evalindents and subsindets as I do not understand applyrule very well.

Given an expression, I want to do an operation each time the pattern  f(arg1)+f(arg2) is found by replacing it by f(arg1+arg2). Regadless of how many there are. For example

f(A)+f(B) -> f(A+B) and  f(A)+f(B)+f(C) -> f(A+B+C)  and so on. But here is the catch, there could be anything else in the expressions. These will be left unchanged. 

So f(A)+f(B)+x -> f(A+B)+x

I can do it in Maple only when the input is exactly f(A)+f(B)  when the input is f(A)+f(B)+f(C) and so on.

But this is not practical as I need to make new type for each case.

I need a general way that will work for any expression like in the above example.

I am now using evalindets, but I do not know how to tell it the type for the general pattern of  f(n1)+f(n2)+.....+f(nn) to replace these with f(n1+n2+....nn).

For reference, this is code in Mathematica I am trying to translate to maple.

expr = Sin[x] + f[A] + f[B] + 10*Exp[x]/13 + Cos[x] + f[c] + f[10*c];
expr //. f[a_] + f[b_] :> f[a + b]

In the above //. means repeated replacement. So it will keep replacing the same pattern over and over and this works regardless of where f(a)+f(b) show up. They can be anywhere in the sum.

I wish I can the same in Maple using evalindets. I tried patmatch also, and same problem. Which is how to make it general. This is what I tried

expr:=f(A)+f(B);
evalindets(expr,`&+`('specfunc(f)','specfunc(f)'),F->f( op([1,1],F) + op([2,1],F) ) );

Which works

But to detect expr:=f(A)+f(B)+f(C) it would need new code

expr:=f(A)+f(B)+f(C);
evalindets(expr,`&+`('specfunc(f)','specfunc(f)','specfunc(f)'),F->f( op([1,1],F) + op([2,1],F) + op([3,1],F) ) );

Obviously this approach will not work. It will also fail once a new term is added in between. 

But how to extend this to the general case of

expr:=sin(x)+f(A)+f(B)+10*exp(x)/13+cos(x)+f(C)+f(10*C);

Is there a way to tell Maple to apply the pattern over and over like with Mathematica so it works for general case? I need to try to do this using either patmatch or evalindets. Ofcourse I can do it the hard way, by iterating over the expression and collecting all the f() and add their arguments one by one each `+` subtype. But that is now what I looking for.  

There should be something similar to how it is done in Mathematica, but using Maple command. Notice that the Mathematica example will work regadless of where the f(a)+f(b) shows up.

expr = Sin[x] + f[A] + f[B] + 10*Exp[x]/13 + Cos[x] + f[c] + 1/(f[10*c] + x + f[99])
expr //. f[a_] + f[b_] :> f[a + b]

ps. may be I need to use subsindets['nocache'] need to look more into it.

Are there rules of thumb to follow to decide to use evalindets vs. subsindets?  They seems to do the same thing, but I did not read every details of the help pages.  Is the difference similar to difference between using eval vs. subs? i.e.

          eval(expr,A=2)

vs.

         subs(A=2,expr) ?

For example

expr:=ln(A)+ln(B);
evalindets(expr,`&+`('specfunc(ln)','specfunc(ln)'),f->ln(op([1,1],f)*op([2,1],f)));
subsindets( expr, `&+`('specfunc(ln)','specfunc(ln)'), f->ln(op([1,1],f)*op([2,1],f)));

Both give

in my program, I keep assumptions in a set. Sometimes this is empty if no assumptions are used. This never caused a problem before (at least I do not think so, else I would have seen it) when using empty {} in assuming, except for now.

Here is one example below. Is this a known problem? I noticed when changing {} to [] the error goes away. I am not sure why, and if this is known issue. But will change from a set to a list to avoid this. 

Maple 2022.2 on windows 10

Download feb_14_2023.mw