Very helpful Neil, thank you. I was unaware of UpValues.

Bryan,

The simplest thing that comes to mind is to do a replace rule at the end. For some reason I can't get optional arguments to work with UpValues. You need to let MMA apply the UpValue rule before the simplest case of just ip. For example,

f = ip + 3* ip^2 + 4*ip^3 /. ip -> 1

will properly give 19 (given my strange definition for ip in the previous post)

Another approach is to define a rule that will do what you want:

In[1]:= myrule = ip^n___ : 1 :> {1, 2, 3, 4}[[Mod[n, 4, 1]]] 

In[2]:= f = ip + 3* ip^2 + 4*ip^3 /. myrule

Out[2]= 19

I tried this same approach with the UpValues but it failed to work (I am reporting it as a bug). I tried:

ip /: ip^n___:1 := {1, 2, 3, 4}[[Mod[n, 4, 1]]] 

This should have made the n optional with a default value of 1. Maybe someone knows another way to make this into a built-in rule. I'll report back what I get from Tech Support.

Regards,

Neil

Bryan,

Short is only a display feature -- it does not affect the values or expressions in any way. Also, I usually try not to display such long outputs because it’s slow (use a semicolon) but no content is lost by the truncated display.

If replaceAll does not get every term it’s because your replacement is adding new terms in. Mathematica will not “miss” any. (And I’ve done many huge expressions!). I suggest you use ReplaceAllRepeated (//.) this will repeat until nothing changes.

Here is an example:

In[1]:= myrule = ip^n___ : 1 :> {1, ip, -1, -ip}[[Mod[n, 4, 1]]];

In[4]:= f = (1 - ip)^2 * (2 + 3*ip + 5* ip^2)

Out[4]= (1 - ip)^2 (2 + 3 ip + 5 ip^2)

In[6]:= g = Expand[f]

Out[6]= 2 - ip + ip^2 - 7 ip^3 + 5 ip^4

In[7]:= g /. myrule

Out[7]= 8 - 4 ip

In[9]:= g //. myrule

Out[9]= 4

Note that Out[7] contains ip but only because my definition (myrule) has ip in it.

I read your other post and I agree with Daniel -- the answer from MMA is correct. Expand is a fast operation. The reason you see such slowdowns is that you are attempting to print ever increasingly complex expressions. Rerun your computation with a semicolon on the end of all the lines-- you will see a monumental speedup in your code. Besides you can't make sense of such a large output and it really brings the machine to its knees. To "explore" such long output look at chunks (myexpression[[1;;20]] to see the first 20 terms, etc.

Regards

Neil