Defining Multiple Forms of a Function for Different Purposes

*To*: mathgroup at smc.vnet.net*Subject*: [mg36748] Defining Multiple Forms of a Function for Different Purposes*From*: "A.M. Sauer-Budge" <ambudge at MIT.EDU>*Date*: Sun, 22 Sep 2002 04:32:30 -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