MathGroup Archive 2006

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Evaluating x^0

  • To: mathgroup at smc.vnet.net
  • Subject: [mg63589] Re: [mg63553] Evaluating x^0
  • From: Andrzej Kozlowski <akoz at mimuw.edu.pl>
  • Date: Fri, 6 Jan 2006 05:24:33 -0500 (EST)
  • References: <200601050812.DAA19824@smc.vnet.net>
  • Sender: owner-wri-mathgroup at wolfram.com

On 5 Jan 2006, at 17:12, ted.ersek at tqci.net wrote:

> Many users loathe the idea of to modifying built-in functions.  
> Especially
> functions such as Set, Plus that are frequently used.  At the very  
> least
> we make calculations run slower when we make such changes, and I agree
> that one must be careful about unintended consequences. Indeed we have
> found that clearing attributes that normally come with built-in  
> functions
> often leads to trouble.
>
> However, I enjoy finding ways to change built-in functions that  
> some would
> view as an improvement, and see how well my changes work.
> --------------------------------------------
>
> Consider evaluating  Clear[x];x^0
> Mathematica returns the Integer 1.
> In doing so Mathematica is assuming (x != 0) since 0^0 is  
> Indeterminate.
>
>
> I wrote to Wolfram Technical Support about this, and their reply  
> included:
>
>>
>> This is a typical auto-simplification issue. Which simplifications
>> should be made automatically and which ones shouldn't can often be
>> subjective. Generally, the convention Mathematica takes is this.
>> Don't make an assumption if it is invalid for a class of values. But
>> it is ok to make an assumption if it is only violated by a small set
>> of specific values.
>>
>> So Sqrt[x^2] does not simplify to Abs[x] (since this is not true for
>> complex numbers). But x/x does simplify to 1 (even though this is not
>> true for 0 or Indeterminate).
>>
>
> That sounds reasonable. However, sometimes a user might want (x^0)  
> to evaluate
> to itself, but it can't be done. It might be better if the rules for
> simplifications that are invalid some of the time could be removed/ 
> disabled
> by the user (e.g. stored in DownValues[Power]). I wonder if  
> calculations would
> run a lot slower if we could do that?
>
> ---------------------
> There are things we can do to make (x^0) evaluate more carefully.  
> One approach
> is to make Power post a message warning you about the assumption  
> being made.
> You can always turn off the message if you want to. Here is some  
> code to make
> Power do this.
>
>
> In[1]:=
>   Unprotect[Power];
>   Clear[Power];
>
>   Power::assum="The expression Power[`1`,`2`] is evaluating to 1  
> which is
>   only true when (`1`) is not zero.";
>
>   Power[x_?(!NumericQ[#]&), 0]/;Message[Power::assum,x,0]:= "Never  
> get here."
>
>
> -----------------------------
> Another approach is to make (x^0) evaluate to an  If[...]  
> expression using
> the code that follows. This however isn't pretty, because it makes  
> (x^0)
> evaluate to something more complicated than (x^0).
>
>
> In[5]:=
>   Unprotect[Power];
>   Clear[Power];
>   Power[x_,0]:= If[x!=0,1,Indeterminate]
>
>
> -----------------------------
> Still another approach is to make (x^0) evaluate to some other  
> expression.
> We then ensure the output is displayed as if (x^0) evaluated to  
> itself.
> The code that follows does this.
>
>
> In[8]:=
>   Unprotect[Power];
>   Clear[Power];
>
>   Power[x_?(!NumericQ[#]&),0]:=power0[x,0];
>   power0[x_?NumericQ,y_]:=Power[x,y];
>
>   MakeBoxes[power0[x_Plus,y_], form:(StandardForm|TraditionalForm)]:=
>      SuperscriptBox[RowBox[{"(",MakeBoxes[x,form],")"}],MakeBoxes 
> [y,form]];
>
>   MakeBoxes[power0[x_,y_], form:(StandardForm|TraditionalForm)]:=
>      SuperscriptBox[MakeBoxes[x,form],MakeBoxes[y,form]];
>
>
> ----------------------------
> Normally the next output would be the Integer 1,
> but not with my definitions above.
>
> In[14]:=
>   Clear[y];
>   tst=(2+y)^0
>
>
> Out[15]=
>   (2 + y)^0    (* Displayed as a SuperscriptBox in the front-end. *)
>
>
> In the output above it looks like (2+y)^0  evaluated to itself,
> but the True InputForm is given below.
>
>
> In[16]:=
>   InputForm[tst];
>
> Out[16]=
>   power0[2+y,0]
>
>
> -----------------------------
> As far as I can tell, the only "problem" with my last approach is  
> that an
> expression with the head (power0) doesn't match the pattern (_Power).


Well, I don't know... how about this:



x^n/y^n - x^n/x^m /. {x -> y, n -> m}


1 - y^0

I think the answer 0 is better in such cases.

Andrzej Kozlowski


  • Prev by Date: Re: Puzzle Challenge
  • Next by Date: Re: Best linear Fit to slope data with Fixed starting point/value.
  • Previous by thread: Evaluating x^0
  • Next by thread: Plot a function on Time Scales