       • To: mathgroup at yoda.physics.unc.edu
• Subject: Finite Function (Follow up)
• From: roger at isy.liu.se (Roger Germundsson)
• Date: Mon, 30 Sep 91 13:51:21 +0100

```This is a followup to my previous posting

Does anyone out there know of a good way of handling
finite functions in Mathematica?

One obvious way would be to use:

f[x1] = y1; f[x2] = y2; ...

Then you would have make f a global variable (!!!)
This approach is implemented in BuildFunction[] below.
Another obvious choice would be to use lists as follows

{{x1, y1}, {x2, y2}, ... }

and then search this list. This is implemented in
Lookup[] below. However this will run at least one
order of magnitude slower than the first approach.

What I think is really needed is something like Maples
table construct which build a list representation, but
packs a hashing function along with that (This is probably
the way Mathematica has implemented the approach
f[x1] = y1, ... ). This would enable you to send such
objects as arguments to functions and also receive those.

See below for implementation and experimental data:

***** Stuff deleted *****

// Roger Germundsson (roger at isy.liu.se)

Thanks everyone (R.Maeder, Bill MacGregor, pkatula at wri.com)

Summary:

(R.Maeder) 	One can use the first approach above without the
pitfalls of global variables by making them unique.
This can be done in the Module[ ] construct
of V2.0 or as below in V1.2.

(Bill MacGregor)Another way to get the speed of the first approach
above and still not have to use global variables
is to view a function as a list of rules and
then use Dispatch[] to pack the hashing function
along with that. (Or whatever optimazition is
performed). Note: Dispatch[] is used automatically
if the first approach is taken.

(pkatula at wri.com) Basically that the first approach can be used and
that contexts can be used to ensure the global
symbols to be unique.

See, below for revised implementation and result:
(For those who want to know this is V1.2 on a Sparc2 16MB)

// Roger Germundsson (roger at isy.liu.se)

(*
These functions assume that fun looks like:
{ { x1, f[x1] }, ... ,{ xn, f[xn] } }
*)

Lookup[ fun:{{_,_}...}, key_ ] :=
Block[{pos},
(* Assume only one match .. since function *)
pos = Flatten[ Position[ fun, {key,_}] ];
Last[ Last[ fun[[ pos ]] ] ]
]

BuildGlobalFunction[ fun:{{_,_}...}, fname_ ] :=
(
Apply[ (fname[#1] = #2)&, fun, {1} ];
fname
)

BuildUniqueFunction[data:{{_, _}...}] :=
Block[{sym = Unique[], key = Unique[]},
Apply[ (sym[#1] = #2)&, data, {1} ];
Function[Release[key],Release[ sym[key] ]]
]

flist = Table[ {i,Random[Integer,{0,10}]}, {i,1,100}];

TLook[k_] :=
Timing[
Do[ Lookup[flist, Random[Integer,{1,100}] ], {k} ];
][]/Second

TGlobFun[k_] :=
Timing[
(
Clear[F];
BuildGlobalFunction[flist,F];
Do[ F[ Random[ Integer, {1,100}] ], {k} ];
)
][]/Second

TUniFun[k_] :=
Timing[
(
Clear[F];
F = BuildUniqueFunction[flist];
Do[ F[ Random[ Integer, {1, 100} ] ], {k} ];
)
][]/Second

(* Results:

Mathematica (sun4) 1.2 (June 13, 1990) [With pre-loaded data]
by S. Wolfram, D. Grayson, R. Maeder, H. Cejtin,
S. Omohundro, D. Ballman and J. Keiper
with I. Rivin and D. Withoff
-- X11 windows graphics initialized --

In:= <<FiniteFunction1.m

In:= tunifun = Table[ TUniFun[ k ], {k, 1000, 10000, 1000} ]

Out= {0.633333, 1.15, 1.61667, 2.16667, 2.71667, 3.23333, 3.61667,

>    4.11667, 4.73333, 5.23333}

In:= tglobfun = Table[ TGlobFun[ k ], {k, 1000, 10000, 1000} ]

Out= {0.583333, 0.933333, 1.36667, 1.78333, 2.2, 2.65, 3.06667,

>    3.45, 3.86667, 4.28333}

In:= tlook = Table[ TLook[ k ], {k, 1000, 10000, 1000} ]

Out= {9.51667, 19.6667, 29.4333, 39.3333, 49.4, 59.0833, 68.9667,

>    78.8, 88.4167, 98.5333}

*)

```

• Prev by Date: Re: Funny Limits
• Next by Date: Re: Funny Limits
• Previous by thread: Student MS-DOS version of Mathematica
• Next by thread: Re: Finite Functions / hash/ fast dispatch