Re: Passing function arguments as lists of replacement rules

*To*: mathgroup at smc.vnet.net*Subject*: [mg104706] Re: [mg104661] Passing function arguments as lists of replacement rules*From*: "David Park" <djmpark at comcast.net>*Date*: Sat, 7 Nov 2009 06:49:28 -0500 (EST)*References*: <3794357.1257503749087.JavaMail.root@n11> <004601ca5ee9$21b680c0$65238240$@net> <29412214.1257538683067.JavaMail.root@n11>

Leo, This is certainly an interesting question and it is very worthwhile writing routines that make it easy to use Mathematica for your particular purposes. I call them convenience routines. There may be many ways to do this and you may get many suggestions, including dynamic input. Here is one other possibility with a sample foo that has most of the features that you want. ClearAll[foo] Options[foo] = {PrintParameters -> False}; foo[parameters_List: {1, 2, 3}, OptionsPattern[]][x_, y_] := Module[{a, b, c}, {a, b, c} = parameters; If[OptionValue[PrintParameters], Print[{a, b, c}]]; a x + b y + c x y ] Now we could just use this in a normal manner: foo[][x, y] foo[PrintParameters -> True][x, y] foo[{3, 2, 1}][x, y] But if you wanted to actually edit the input parameters, and maybe if you had a longer list of parameters, you could first type the following statement: With[ {a = 1,(* Temperature Kelvin *) b = 2, (* Velocity m/s *) c = 3}, (* Altitude meters *) foo[{a, b, c}][x, y]] Now open up the cell to get the underlying expression. (Shift-Ctrl-E, or Menu -> Cell -> Show Expression) Copy the Cell expression. Then paste it in the following expression: fullfoo := CellPrint[Cell[BoxData[RowBox[{"With", "[", " ", RowBox[{RowBox[{"{", RowBox[{RowBox[{"a", "=", "1"}], ",", RowBox[{"(*", " ", RowBox[{"Temperature", " ", "Kelvin"}], " ", "*)"}], " ", RowBox[{"b", "=", "2"}], ",", " ", RowBox[{"(*", " ", RowBox[{"Velocity", " ", RowBox[{"m", "/", "s"}]}], " ", "*)"}], " ", RowBox[{"c", "=", "3"}]}], "}"}], ",", " ", RowBox[{"(*", " ", RowBox[{"Altitude", " ", "meters"}], " ", "*)"}], " ", RowBox[{RowBox[{"foo", "[", RowBox[{"{", RowBox[{"a", ",", "b", ",", "c"}], "}"}], "]"}], "[", RowBox[{"x", ",", "y"}], "]"}]}], "]"}]], "Input"]] Now, if you evaluate fullfoo, you will obtain the initial expression with the default values of the parameters and annotation. One can then just edit whichever values one wishes, or put the option into foo, and evaluate. So, you can have it both ways, short if you set the parameters once and for all, and long if you want to play with the parameters. The long way is also nice if you are writing it for someone else who doesn't know Mathematica that well and you don't know what changes they may wish to make. David Park djmpark at comcast.net http://home.comcast.net/~djmpark/ From: leo.alekseyev at gmail.com [mailto:leo.alekseyev at gmail.com] On Behalf Of Leo Alekseyev This is certainly one option, but does it have any benefits over the list of string replacement rules?.. I recently started using both the options pattern _and_ a replacement list. The actual functions I'm working with look something like foo[x_,y_,parameters_,OptionsPattern[]], where x and y are bona fide dependent variables, parameters is a list of fixed constants pertinent to the system (provided as replacement rules of the form, e.g. {"a"->1,...}, and OptionsPattern[] conveys certain options pertaining to the computation itself, e.g. {AvoidDivideByZero->True} So far it seems like a sensible approach, but I am still wondering if other people do similar things in their code. --Leo On Fri, Nov 6, 2009 at 8:57 AM, David Park <djmpark at comcast.net> wrote: > Use the newer Version 6 Options facilities. > > ClearAll[foo] > Options[foo] = {a -> 0, b -> 0, c -> 0}; > SyntaxInformation[foo] = {"ArgumentsPattern" -> {OptionsPattern[]}}; > foo[OptionsPattern[]] := > Module[ > {aval = OptionValue[a], > bval = OptionValue[b], > cval = OptionValue[c]}, > {aval, bval, cval}] > > foo[a -> 1, b -> 2] > {1, 2, 0} > > Then try typing: > > foo[a -> 1, q -> 2] > > > David Park > djmpark at comcast.net > http://home.comcast.net/~djmpark/ > > > From: dnquark [mailto:dnquark at gmail.com] > > > I wish to (a) avoid having to pass a dozen parameters to a function > and have to deal with remembering which goes where and (b) retain the > flexibility in terms of adding new parameters. It seems that a good > solution would be to pass my parameters as a structure with named > fields (this is how I do it in another system). In Mathematica, I came up > with something like this: > > foo[paramList_] := Module[{a,b,c}, > {a,b,c} = {"a","b","c"}/.paramList; > {a,b,c} > ] > sample usage: e.g. foo[{"a"->1,"b"->2}] > > My question to the group: is this a good solution? Are there better > ways to achieve my goals?.. > Thanks, > --Leo > > >