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

MathGroup Archive 1991

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

Search the Archive

Finite Function (Follow up)

  • 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 
about finite functions:

	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)
for your responses.

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} ]; 
	][[1]]/Second

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

TUniFun[k_] :=
	Timing[ 
		(
		Clear[F];
		F = BuildUniqueFunction[flist];
		Do[ F[ Random[ Integer, {1, 100} ] ], {k} ];
		)
	][[1]]/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
Copyright 1988,1989,1990 Wolfram Research Inc.
 -- X11 windows graphics initialized -- 

In[1]:= <<FiniteFunction1.m

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

Out[2]= {0.633333, 1.15, 1.61667, 2.16667, 2.71667, 3.23333, 3.61667, 
 
>    4.11667, 4.73333, 5.23333}

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

Out[3]= {0.583333, 0.933333, 1.36667, 1.78333, 2.2, 2.65, 3.06667, 
 
>    3.45, 3.86667, 4.28333}

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

Out[4]= {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