4

I'm trying to write a rule that acts on any number, lists, expression and so on to turn any negative numbers positive.

The simple r = n_ -> Abs[n] works perfectly well for numbers, lists and nested lists, but does not work expressions, such as Exp[-5], which is unaffected by my rule. I can't use the replace function, because I also require my rule to work for other Mathematica inputs, like numbers, lists and nested lists.

Can someone suggest why this does not work? Is it due to the rule not penetrating the expression? An edit to my rule would also be much appreciated.

Pablo
  • 155
  • 5
  • 2
    I think it is working, but it's working on Exp[-5]. Trace shows you the sequence of evaluation steps: Trace[Exp[-5] /. r]. Perhaps Exp[-5] /. n_?NumberQ :> Abs[n] is what you're after? – Michael E2 Jan 29 '16 at 13:27
  • @MichaelE2, using your method, why can we get (-E)^(-5) to return E^5, but we can't get (-2)^(-5) to return 2^5? Changing the -2 to -2.0 doesn't change it either. – Jason B. Jan 29 '16 at 13:44
  • @JasonB Perhaps Trace and the observation that NumberQ[E] is False leads to an explanation. E.g., (-2)^(-5) evaluates to -1/32 before any rules are applied. See if you can figure out HoldForm[(-2)^(-5)] /. n_?NumberQ :> Abs[n] // Trace -- it stumped me at first. Inactivate[(-2)^(-5)] /. n_?NumberQ :> Abs[n] is the only way I figured out to do what you want. – Michael E2 Jan 29 '16 at 14:02
  • For Log[1/E], do you want to get 1 or -1? (I.e. do you want Abs[ Log[ Abs[ Abs[1]/Abs[E]]]] or only Log[ Abs[1/E]], respectively?) – Eric Towers Jan 29 '16 at 17:44
  • 2
    This question needs a good size set of example inputs with desired outputs. Too many people are needing too many guesses to sort out what actually is wanted, and that amounts to wasted time. – Daniel Lichtblau Jan 29 '16 at 18:34

3 Answers3

5

A few more examples provided at suggestion of OP.

Replace[Unevaluated[{Exp[-5], -7, (-2)^(-5), BesselJ[-2, -3], 
    Cos[-5], {-Pi, -E}, Exp[-5 Exp[-5]]}], n_ -> Abs[n], {0, Infinity}]

(* {E^5, 7, 32, BesselJ[2, 3], Cos[5], {π, E}, E^(5 E^5)} *)

may be what you want. (Note:. Unevaluated needed to handle (-2)^(-5).)

Addendum

This can be written as a function by

f = Function[x, Replace[Unevaluated[x], n_ -> Abs[n], {0, Infinity}], HoldAll]

Then, 

f@{Exp[-5], -7, (-2)^(-5), BesselJ[-2, -3], Cos[-5], {-Pi, -E}, Exp[-5 Exp[-5]]}
(* {E^5, 7, 32, BesselJ[2, 3], Cos[5], {π, E}, E^(5 E^5)} *)

as before.

bbgodfrey
  • 61,439
  • 17
  • 89
  • 156
  • Thank you for your help, but I should have made my question clearer (I have just edited it). I require this rule to work for all kinds of mathematica inputs, such as numbers, lists of numbers, Cos[-5] and so on. Therefore, Replace won't work since it is far too specific. – Pablo Jan 29 '16 at 13:34
  • @Pablo Works for those too. See addition to list of examples. The third argument, Infinity, causes Replace to reach inside functions. The suggestion by MichaelE2 works well too, of course. – bbgodfrey Jan 29 '16 at 13:39
  • @bbgodfrey I believe Reduce[ expr, n_?NumberQ -> Abs[n], Infinity] might work and be more precise? (Oh, I see that is what MichaelE2 has suggested above) – gwr Jan 29 '16 at 13:40
  • @gwr Certainly, your suggestion works too, but I am not sure what you mean by "more precise". – bbgodfrey Jan 29 '16 at 13:42
  • @bbgodfrey While testing ?NumberQ takes time, we will not need to have nested Abs[ ] in a nested expression, but that is what we will get without the filtering. – gwr Jan 29 '16 at 13:50
  • @bbgodfrey I tried your suggestion in the following form r = m_ -> Replace[{m}, n_ -> Abs[n], Infinity], in an attempt to be able to apply this rule to any function, but unfortunately it doesn't work. For example, -7/.r = m_ -> Replace[{m}, n_ -> Abs[n], Infinity] simply returns -7. I don't understand why this won't work, despite the fact than when I plug r = m_ -> Replace[{-7}, n_ -> Abs[n], Infinity] directly it works fine. – Pablo Jan 29 '16 at 13:53
  • @Pablo That is a Precedence issue so you will need -7 /. ( r = m_ -> ...) – gwr Jan 29 '16 at 13:53
  • I'm sorry @gwr , I don't really understand what you're suggesting. Even when I wrap brakes around as I think you are suggesting, it does not work Exp[-5] /. (m_ -> Replace[{m}, n_ :> Abs[n], Infinity]) – Pablo Jan 29 '16 at 13:56
  • @Pablo What you are trying is not what I suggested in my answer. Use Replace[Unevaluated[list of stuff], n_ -> Abs[n], {0, Infinity}] to make all parts of list of stuff positive. – bbgodfrey Jan 29 '16 at 14:00
  • @bbgodfrey Unfortunately, for that to work though, I will need to input every single possible combination of lists in to that first argument, which is impossible. I need to be able to apply some rule that will turn any arbitrary term that contains numbers that are negative into a term that is equivalent to the first, except with positive numbers. For example, Exp[-5] /. m_ -> Replace[Unevaluated[m], n_ -> Abs[n], {0, Infinity}] should output E^5, but it does not. – Pablo Jan 29 '16 at 14:09
  • @Pablo The functional form added to my answer may get closer to your goal. Just prefix f@ to an expression to change all numbers in it to positive. (In some instances, you may need to enclose the expression in parentheses.) – bbgodfrey Jan 29 '16 at 14:57
2

Exp[-5] is not unaffected by your rule at all; on the contrary,

Trace[Exp[-5]/.n_->Abs[n]]

shows that Exp[-5] is replaced by Abs[Exp[-5]], which is equal to Exp[-5]. If you only want stuff that "looks like" numbers to get replaced, you can use

Replace[Exp[-5],n_->Abs[n]],-1]

which replaces anything that does not have a sub-part, i.e. it would give

e^5

But what about stuff like (-2)^(-5)? Do you want to replace both (-2) and (-5)?

Marius Ladegård Meyer
  • 6,805
  • 1
  • 17
  • 26
  • Yes, I want to change every single thing that "looks like" a number from negative to positive before completing the operation. Thank you for your edit on the Exp[-5] example – Pablo Jan 29 '16 at 13:25
2

In slight modification of @bbgodfrey's excellent answer, what you might use is this:

SetAttributes[ f, HoldAll ];
f[ expr_ ] := Replace[
      HoldForm @ expr, (* prevent any evaluation before replacement *)
      n_ -> Abs[n], (* ?NumberQ would not work then *)
      Infinity
    ]//ReleaseHold;


f[ (-2)^(-5) ]

32

gwr
  • 13,452
  • 2
  • 47
  • 78
  • 1
    So you might use Replace[ HoldForm @ expr, n_?NumberQ -> Abs[n], Infinity]//ReleaseHold. – gwr Jan 29 '16 at 14:09
  • There are subtle differences for HoldForm and Unevaluated which I have not pondered too far. With Unevaluated there is no need for a ReleaseHold. – gwr Jan 29 '16 at 14:28