Mathematica 9 is now available
Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
2002
*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 2002

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

Search the Archive

Maintaining Multiple Forms of a Function For Different Purposes

  • To: mathgroup at smc.vnet.net
  • Subject: [mg36745] Maintaining Multiple Forms of a Function For Different Purposes
  • From: "A.M. Sauer-Budge" <ambudge at MIT.EDU>
  • Date: Sun, 22 Sep 2002 04:32:25 -0400 (EDT)
  • Sender: owner-wri-mathgroup at wolfram.com

I would like to build my Mathematica notebooks in manner which allows me 
to carry out two overlapping purposes: 1) prototype an algorithm 
completely within Mathematica, 2) use Mathematica as a partial evaluator 
to splice derived expressions into a C language version of the algorithm (
with the aid of the Format package from MathSource).  The key 
complication in doing this is that for the Mathematica prototype I want 
everything to be evaluated, while for splicing I want the results from 
some of the functions to be retained as data in temporary variables.

A first step towards these purposes is simple: write my component 
functions so they operate on lists (the natural form of the prototype 
data), then provide lists of arrays for arguments which I would like to 
supply as data in the resulting C language output forms.

An example:
--------------------------------------------------
In[1]:= t[x_] := {x[[4]]-x[[3]], x[[2]]-x[[1]]}
In[2]:= f[x_,y_] := {y, 1}.t[x]

In[3]:= f[{1,2,3,4},2]
Out[3]= 3

In[4]:= f[Array[x,4],2]
Out[4]= -x[1] + x[2] + 2 (-x[3] + x[4])

In[5]:= CAssign[fcnval, f[Array[x,4],2], AssignToArray->{x}]
Out[5]//OutputForm= fcnval=-x[1]+x[2]+2.*(-x[3]+x[4]);
--------------------------------------------------

For various reasons, however, I would like certain expressions of my 
symbolic derivation to be treated as data for the C language version.  
In the above example, for instance, I would like the array that function 
t produces to be a data array. 

The modification of the above example:
--------------------------------------------------
In[6]:= tc[x_] := Array[tt,2]
In[7]:= fc[x_,y_] := {y, 1}.tc[x]

In[8]:= CAssign[tt, t[Array[x,4]], AssignToArray->{x}]
Out[8]//OutputForm= tt[0]=-x[3]+x[4];
                     tt[1]=-x[1]+x[2];

In[9]:= CAssign[fcnval, fc[Array[x,4],2], AssignToArray->{tt}]
Out[9]//OutputForm= fcnval=2.*tt[1]+tt[2];
--------------------------------------------------

But I don't want to carry around two versions of everything, nor do I 
really want to thread all of the supporting functions through my 
definitions in order to choose the correct function for the purpose  I 
would rather define the C language alternatives only for functions like 
t and tc in the example, with f using the appropriate one depending on 
some evaluation flag that I set at the highest level.

For example, it would be nice to be able to sprinkle in the C language 
alternatives with a construct like

In[10]:= t[x_] := {x[[4]]-x[[3]], x[[2]]-x[[1]]}
In[11]:= DefineTemporaryForm[t[x_]] := Array[tt,Length[x]/2]

then be able to write

In[8]:= CAssign[tt, t[Array[x,4]], AssignToArray->{x}]
Out[8]//OutputForm= tt[0]=-x[3]+x[4];
                     tt[1]=-x[1]+x[2];

In[9]:= CAssign[fcnval, UseTemporaryForm[f[Array[x,4],2]], AssignToArray-
>{tt}]
Out[9]//OutputForm= fcnval=2.*tt[1]+tt[2];

I would appreciate any pointers on a good, clean and hopefully simple 
way to do this within Mathematica!

Thanks,
Alex


  • Prev by Date: Defining Multiple Forms of a Function for Different Purposes
  • Next by Date: RE: Re: Ball Rolling down on Cosh[t] Path
  • Previous by thread: Defining Multiple Forms of a Function for Different Purposes
  • Next by thread: how to plot with BOLD LINE with mathematica?