Simplifying expressions for use in C programs

• To: mathgroup at smc.vnet.net
• Subject: [mg22051] Simplifying expressions for use in C programs
• From: Wagner Truppel <wtruppel at uci.edu>
• Date: Fri, 11 Feb 2000 02:38:32 -0500 (EST)
• Sender: owner-wri-mathgroup at wolfram.com

```Hi,

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
with.

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 uci.edu

```

• 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