Re: Picking Arguments
- To: mathgroup at smc.vnet.net
- Subject: [mg74278] Re: Picking Arguments
- From: "Drago Ganic" <dganic at vodatel.net>
- Date: Fri, 16 Mar 2007 03:20:31 -0500 (EST)
- Organization: Customer of Vodatel, Zagreb, CROATIA
- References: <esdka9$ou3$1@smc.vnet.net> <et5npe$jij$1@smc.vnet.net>
Hi,
I just want to add to the difference of Select and Case. I think they
represent two important functions for a different domain of programming:
semantic Select
syntax Cases
which sometimes can be used for the same problem but usually one method is
better that the other for a certain problem.
If you look at all the List manipulation functions we have only three access
methods to the elements of lists:
1. postion => via an integer number, eg. Part[]
2. pattern => via a syntactical pattern, eg. Cases[]
3. logical => via a logical boolean expression, eg. Select[]
Here is a example:
In[1]:= Select[ {1, 2.3, a}, # \[Element] Reals &]
Out[1]= {1, 2.3}
In[2]:= Cases[{ 1, 2.3, a}, _Real ]
Out[2]= {2.3}
In[3]:= Cases[{ 1, 2.3, a}, _Integer | _Rational | _Real]
Out[3]= {1, 2.3}
It's a nice example for thinking about what OO inheritance might be in
Mathematica.
I would says that Mathematica defines "types" in a syntactical way (head of
expression) and uses them in pattern matching function (e.g. Cases), and
defines "domain" in a more semantical (logical/mathematical) way and uses
them in other functions (like Select).
Of course types in Mathematica are more something like IntegerQ[] and not
_Integer and hence are a semantical "thing" and not just syntactical.
Greeting from Croatia,
Drago
"dimitris" <dimmechan at yahoo.com> wrote in message
news:et5npe$jij$1 at smc.vnet.net...
> As a second thought to your query I would suggest you to read
> carefully the reply of
> Andrzej Kozlowski to the recent thread with the title: "Map function
> which adds last two numbers of a list".
> Not very relevant at first glance but I think it talks about the right
> "attitude" for attacking a "real" problem.
>
> http://groups.google.gr/group/comp.soft-sys.math.mathematica/browse_thread/=
> thread/3b38366201665b24/9c76eb8c939ce75d?lnk=st&q=&rnum=28&hl=el#9c=
> 76eb8c939ce75d
>
>
> Anyway...
>
> You have many ways to do what you want. You found by yourself (well
> done!) that Cases gives your desired output.
>
> So why hanging around with Select?
>
> You could say for programming practise. But (at least!) for me the
> important thing is to understand that Select is not "designed" for
> doing things like what you desire. Cases is the key here (or other
> built in functions suggested in the replies you got by some of the
> gurus of this beautiful forum; no I don't talk about myself! I talk
> about Bob Hanlon and Jean-Marc Gulliet!) . Not Select; except if you
> just want to end with an extravagant code! So what? What's the deal?)
>
> As regards myself, Understanding the (BIG!) Difference between Select
> and Cases is the most important thing.
>
> I copy directly from M. Trott's Guidebook for Programming...
>
> Select picks the arguments according to the truth value, and it
> delivers the result with the same head as the selected expression.
> Cases chooses according to patterns, and it gives a result in the form
> of a list. The optional third argument in the two functions also has a
> completely different role. In Select, it defines the number of objects
> to be selected, whereas in Cases, it gives the level specification at
> which the first argument is to be tested.
>
> Another issue which you should be more aware of (in my point of view
> of course!) is why RuleDelayed is
> unnessary here.
>
> A = {f[x], g[p, q, r, s], h[u, v, w]}
> {f[x], g[p, q, r, s], h[u, v, w]}
>
> Cases[A, _[args__] :> {args}]
> {{x}, {p, q, r, s}, {u, v, w}}
>
> Cases[A, _[args__] -> {args}]
> {{x}, {p, q, r, s}, {u, v, w}}
>
> Trace[Cases[A, _[args__] :> {args}]]
> {{HoldForm[A], HoldForm[{f[x], g[p, q, r, s], h[u, v, w]}]},
> HoldForm[Cases[{f[x], g[p, q, r, s], h[u, v, w]}, _[args__] :>
> {args}]], HoldForm[{{x}, {p, q, r, s}, {u, v, w}}]}
>
> Trace[Cases[A, _[args__] -> {args}]]
> {{HoldForm[A], HoldForm[{f[x], g[p, q, r, s], h[u, v, w]}]},
> HoldForm[Cases[{f[x], g[p, q, r, s], h[u, v, w]}, _[args__] ->
> {args}]], HoldForm[{{x}, {p, q, r, s}, {u, v, w}}]}
>
>
> What about here?
>
> sols = Solve[x^3 == 1]
> {{x -> 1}, {x -> -(-1)^(1/3)}, {x -> (-1)^(2/3)}}
>
> sols /. (a_ -> b_) -> a -> ComplexExpand[b]
> {{x -> 1}, {x -> -(-1)^(1/3)}, {x -> (-1)^(2/3)}}
>
> sols /. (a_ -> b_) :> a -> ComplexExpand[b]
> {{x -> 1}, {x -> -(1/2) - (I*Sqrt[3])/2}, {x -> -(1/2) +
> (I*Sqrt[3])/
> 2}}
>
>
> If you have finished the relevant material in the Help Browser about
> (the so much!) useful Built-in Symbols
> like Select, Cases, Fold, Nest, Map, Apply of Functional Progarmming
> and you want more things to read/practise (and avoid unnessary hanging
> around...) trying
>
> http://verbeia.com/mathematica/tips/Tricks.html
> http://verbeia.com/mathematica/tips/GraphicsTricks.html
>
> that is the (very famous and so properly called) Suplementary Help
> Browser of Ted Ersek!
> As notebooks see here:
>
> http://library.wolfram.com/infocenter/MathSource/4557/
>
> Very challenging material!
>
>
> And here is something truly amazing!
>
> http://documents.wolfram.com/flash/
>
> See also here
>
> http://library.wolfram.com/infocenter/MathSource/4286/
>
> and here
>
> http://www.mathematica.co.kr/
>
>
> Best Regards
> Dimitris
>
>
>
> =CF/=C7 Mr Ajit Sen =DD=E3=F1=E1=F8=E5:
>> Dear MathGroup,
>>
>> Given a list of functions
>>
>> A={f[x],g[p,q,r,s],h[u,v,w]},
>>
>> I'd like to pick out their arguments as a list.
>>
>> Cases[A,_[args__]:>{args}]
>>
>> works fine returning {{x}, {p,q,r,s}, {u,v,w}}.
>>
>> How do I achieve the same thing with Select ?
>>
>>
>> Thanks for your help.
>>
>> Ajit Sen
>>
>>
>>
>>
>>
>> ___________________________________________________________
>> Yahoo! Messenger - NEW crystal clear PC to PC calling worldwide with
>> voic=
> email http://uk.messenger.yahoo.com
>
>