MathGroup Archive 2000

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

Search the Archive

Simplifying expressions for use in C programs


I'm currently working with very large expressions that are going to 
be hard-coded in a C program, and I'd like to pre-process them using 
Mathematica so as to accomplish the following tasks:

- minimize the number of multiplications
- re-define common sub-expressions as new variables

For instance, if

d = - x * z^2 * y^2 - (z^5 - x * y^2)*y^3 + (x^3 - y^5)^2 + (z^5 - x * y^2)^3

which is much much simpler than the simplest expression I actually 
have to deal with, I'd like to have Mathematica pre-process it and 
output something like this (sans the comments, added here to clarify 
my notation for powers):

x3 = x * x * x;

y2 = y * y;
y3 = y * y2;
y5 = y2 * y3;

z2 = z * z;
z5 = z * z2 * z2;

aux1 = (x^3 - y^5);
aux1p2 = aux1 * aux1; /* p2 stands for power 2 */

aux2 = (z^5 - x * y^2);
aux2p3 = aux2 * aux2 * aux2; /* p3 stands for power 3 */

d = - x + z2 + y2 - aux2 * y3 + aux1p2 + aux2p3;

(variable type declarations can easily be added, of course)

Naturally, I'd start with calling Simplify[], whose default behavior 
tries to minimize the number of terms in the input expression. 
Figuring out all the powers appearing in the expression doesn't seem 
hard (something like Cases[d, _^_, {0,Infinity}] ought to do it), and 
figuring out how to break those powers in a way that minimizes the 
number of multiplications also isn't too difficult.

For instance, since x already appears in d, but x^2 does not, x3 is 
defined as x*x*x rather than x*x2, which would require another 
variable to be defined (although the number of multiplications 
remains two in both cases, since x2 = x*x). Similarly, since y3 has 
to be defined anyway, y5 can be defined as y2*y3, but z5 = z*z2*z2 
since z2 does not have to be defined. I've already written a function 
to break powers in this fashion: given a list of positive integers, 
choose one at a time and try to write it as the sum of either a pair 
or a triplet of the smaller ones. If such pair or triplet cannot be 
found for a given number, insert half the troubled number (or both 
the Ceiling[] and the Floor[] of half of the number, if it's odd) 
into the list and start all over again, with the larger list.

My biggest problem is actually recognizing sub-expressions that 
appear frequently. Performing that simplification would save a 
substantial amount of computation given the expressions I'm dealing 

I'm wondering if anyone has had to do things like these or if there 
are already Mathematica notebooks freely available that can perform 
this sort of pre-processing.

Thanks for any and all help.
Wagner Truppel
wtruppel at

  • Prev by Date: Re: global real variables
  • Next by Date: Finding parts of Equations...
  • Previous by thread: Re: Dealing with irregular shaped arrays
  • Next by thread: Re: Simplifying expressions for use in C programs