Mathematica 9 is now available
Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
2000
*January
*February
*March
*April
*May
*June
*July
*August
*September
*October
*November
*December
*Archive Index
*Ask about this page
*Print this page
*Give us feedback
*Sign up for the Wolfram Insider

MathGroup Archive 2000

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

Search the Archive

Re: Simplifying expressions for use in C programs

  • To: mathgroup at smc.vnet.net
  • Subject: [mg22073] Re: Simplifying expressions for use in C programs
  • From: Jens-Peer Kuska <kuska at informatik.uni-leipzig.de>
  • Date: Sat, 12 Feb 2000 04:04:31 -0500 (EST)
  • Organization: Universitaet Leipzig
  • References: <880g01$4sk@smc.vnet.net>
  • Sender: owner-wri-mathgroup at wolfram.com

Hi,

it does not exatly what you need but:

http://www.mathsource.com/Content/Enhancements/Language/0205-939

For your polynoms Hoerner[] may give better results.

Regards
  Jens

Wagner Truppel wrote:
> 
> 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: Mathlink and packed arrays
  • Next by Date: Re: Re: Re: Set in Scan
  • Previous by thread: Re: Simplifying expressions for use in C programs
  • Next by thread: Finding parts of Equations...