Re: removing those annoying $$$$'s from local variables names?
- To: mathgroup at smc.vnet.net
- Subject: [mg79696] Re: removing those annoying $$$$'s from local variables names?
- From: Jon McLoone <jonm at wolfram.co.uk>
- Date: Thu, 2 Aug 2007 03:46:40 -0400 (EDT)
- References: <f8pk78$2i1$1@smc.vnet.net>
On Aug 1, 10:36 am, Nasser Abbasi <n... at 12000.org> wrote: > Hello; > > This is a problem I am sure many have seen. May be there is a simple > solution for it, but I can't find it. > > This problem is when a function returns back a symbol which is local > to the function, then these synbols will have $nnnn tacked to them, > and so when the caller say prints the symbol, it will have those $'s > numbers, which make it annoying to look it and print, say as a table > or such. > > This is an example: > > ------------- example 1 ------------- > > foo[] := Module[{c, k}, > c = Array[k, 3] > ]; > > c = foo[]; > Print[c]; > > {k$76[1], k$76[2], k$76[3]} > -------------------------------------------------- > > You see, since k is local to foo[], then when I print it, I see those $ > $$ signs. > > Only way to remove this $$$'s is to make k global as follows > > ------------------------ example 2 ------------------- > Remove[k]; > foo[] := Module[{c}, > c = Array[k, 3] > ]; > > c = foo[]; > Print[c]; > > {k[1], k[2], k[3]} > ---------------------------------------- > > But making 'k' global is something I do NOT want to do, since now I > have to worry about 'k' having a value somewhere else in the code, and > it goes against the whole idea of encapsulation. If I start making all > my symbols global, then the code becomes hard to manage. > > So, what should one do in this case? How can make all the symbols > local to a function, but at the same time not see these $$$'s when the > symbols are used when they are returned from the function back to the > caller? > > thanks, > Nasser It depends on whether you want two separate calls to foo to return the same k or different k? Put it another way should foo[]-foo[] return {0,0,0} or a pretty version of {k$1[1]-k$2[1],k$1[2]-k$2[2],k$1[2]-k $2[2]} If it is the former user Block instead of Module. In[1]:= foo[] := Block[{c, k}, c = Array[k, 3]]; In[2]:= foo[] Out[2]= {k[1], k[2], k[3]} In[3]:= foo[] - foo[] Out[3]= {0, 0, 0} But note that this is local within the Block but becomes global as it exits. eg In[4]:= x = 1; Block[{x}, {x === 1, x}] Out[5]= {False, 1} The Block returns {False,x} but then x picks up the global value because it is now outside of the Block. If you want the other result, then you need your k to be distinct variables like k$1, k$2 but you want a more pleasing name. Well construct the name yourself. eg k1,k2 etc could be done like this... In[5]:= foo[] := Block[{c, k = Symbol["k" <> ToString[$ModuleNumber++]]}, c = Array[k, 3]]; c = foo[]; Print[c]; During evaluation of In[5]:= {k67[1],k67[2],k67[3]} In[8]:= foo[] - foo[] Out[8]= {k68[1] - k69[1], k68[2] - k69[2], k68[3] - k69[3]} This distinction is only necessary because of the symbolic capabilities of Mathematica. If your output is always numerical there is no conceptual difference between the application of Block and Module. Jon McLoone http://members.wolfram.com/jonm