how to simplify / expand / apply a pattern to a function's argument

Question

(I made some changes...)

very often I want to simplify the function's argument, or apply a pattern to it, eg. I want to change:

Exp[a(b+c)]

into

Exp[a b + a c]

simple pattern doesn't help:

Sin[a(b+c)] /. Sin[aaa_] -> Sin[Expand[aaa]]

gives again

Sin[a(b+c)]

However, with functions other than Simplify / Expand it seems to do what I expect:

Sin[a (b + c)] /. Sin[aaa_] -> Sin[f[aaa]]

gives

Sin[  f[a(b+c)]  ]

My usual solution was to use 2 patterns and Hold:

(Exp[a(b+c)] /. Exp[aaa_] -> Exp[Hold[  Expand[aaa]  ]] ) /. Hold[xxx_] -> xxx

which results in

E^(a*b + a*c)

The disadvantage of this method is that code gets more complicated than it's neccesary.

MY REAL LIFE EXAMPLE is:

ppp2 = 
 ( ppp1  
    /. { ExpIntegralEi[aaa_] -> 
           ExpIntegralEi[Hold[aaa /. { u2 -> 0, w2 -> 0, u3 -> x, w3 -> x}]], 
         Log[aaa_] -> 
           Log[Hold[aaa /. {u2 -> 0, w2 -> 0, u3 -> x, w3 -> x}]]
       }
 ) /.  Hold[xxx_] -> xxx;

where ppp1 is a long sum of terms containing u2, w2, u3, w3 and so on. I want to change the values of u, w2... ONLY in ExpIntegral and Log.

My other solution is a function:

ExpandArgument[expr_, what_] := Module[{list},
  list = Extract[expr, Position[   expr, what[_]   ]];
  list = Map[Rule[#, what[Expand[   #[[1]]   ]]] &, list];
  Return[expr /. list]
]

The function I wrote can be easily generalised to make it possible to use not only Expand but also Simplify and so on:

ApplyToArgument[expr_, ToWhat_, WhatFunction_] := Module[{list},
  list = Extract[expr, Position[   expr, ToWhat[_]   ]];
  list = Map[Rule[#, ToWhat[WhatFunction[   #[[1]]   ]]] &, list];
  Return[expr /. list]
]

For example:

ApplyToArgument[Sin[a (b + c)], Sin, Expand]

gives

Sin[a b + a c]

and

ApplyToArgument[Sin[a b + a c ], Sin, Simplify]

gives

Sin[a (b + c)]

This solution is easy to read but needs some refinement before being applied to many-argument functions (and I need these functions).

I guess I'm missing something fundamental about patterns in mathematica... How should I apply patterns to arguments of functions? (Or simplify, expand, etc. them)

Thanks a lot!

You could use Map (or /@ for short) to apply a function to the arguments of another function. So for your example you could do Expand /@ Sin[a (b + c)] which returns Sin[a b + a c]. If you only want to apply the function to say the first argument, you could use MapAt, e.g. MapAt[Expand, g[a (b + c), d (e + f)], 1] — Heike
– Heike, Commented Nov 9, 2011 at 11:46
@Heike Thanks a lot for the comment. I've changed my question to explain that I dont work with single functions, but with long sums of different functions and I want to change arguments of only one type of them. — au700
– au700, Commented Nov 9, 2011 at 12:04
This question appears to be off-topic because it is about Mathematica and it should be moved to mathematica.stackexchange.com — Saullo G. P. Castro
– Saullo G. P. Castro, Commented Oct 16, 2013 at 10:50

681234 · Accepted Answer · 2011-11-09 12:45:08Z

16

For the first part of the question, you could consider using RuleDelayed:

Sin[a (b + c)] /. Sin[aaa_] :> Sin[Expand[aaa]]

gives

Sin[a b + a c]

answered Nov 9, 2011 at 12:45

681234

4,2842 gold badges41 silver badges45 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

au700 Over a year ago

I didn't mark this answer as an accepted one because I somehow didn't know how to do it. This answer was REALLY helpful, I use it a lot!

celtschk · Accepted Answer · 2011-11-09 13:07:38Z

7

Use :> instead of ->. With ->, the right hand side is immediately evaluated, and only then applied. Expansion of aaa of course gives just aaa, and therefore evaluation of Sin[Expand[aaa]] gives Sin[aaa], thus the rule asks for replacing each application of Sin by itself. Then you also should not need those Hold constructs.

In a related note: Instead of applying the rule Hold[xxx_]->xxx, you can just pass your expression to ReleaseHold, for example ReleaseHold[Hold[1+1] /. 1->2] gives 4.

answered Nov 9, 2011 at 13:07

celtschk

19.8k4 gold badges42 silver badges64 bronze badges

1 Comment

au700 Over a year ago

Thanks a lot! I see the point. Thanks for suggesting ReleaseHold (and providing a nice example).

Arnoud Buzing · Accepted Answer · 2011-11-09 15:32:39Z

2

Also consider using ExpandAll:

ExpandAll[Exp[a (b + c)]] // FullForm

will give:

Power[E, Plus[Times[a, b], Times[a, c]]]

(This will turn Exp[...] into E^... though)

answered Nov 9, 2011 at 15:32

Arnoud Buzing

15.4k3 gold badges23 silver badges50 bronze badges

Comments

Szabolcs · Accepted Answer · 2011-11-09 16:54:35Z

2

This is not a direct answer (others provided that), but for these kinds of manipulations the Algebraic Manipulation Palette (Palettes -> Other) is often quite convenient:

enter image description here

The disadvantage is that unlike typed-in commands, this operation won't be "recorded" and saved in the notebook.

answered Nov 9, 2011 at 16:54

Szabolcs

25.8k11 gold badges88 silver badges192 bronze badges

Collectives™ on Stack Overflow

how to simplify / expand / apply a pattern to a function's argument

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related