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

MathGroup Archive 2006

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

Search the Archive

Re: DownValues and Cases

  • To: mathgroup at smc.vnet.net
  • Subject: [mg70784] Re: [mg70759] DownValues and Cases
  • From: Andrzej Kozlowski <akoz at mimuw.edu.pl>
  • Date: Fri, 27 Oct 2006 00:28:37 -0400 (EDT)
  • References: <3282293.2074281161897563457.JavaMail.root@vms073.mailsrvcs.net>

That will, of course, solve the problem you asked about, concerning  
DownValues. But it would not solve the more general problem with  
HoldPattern (admittedly one that is not very likely to occur  
naturally) . Suppose we have the definitions

f[x_] := 1; g[x_] := 2;

and consider the list

h = {HoldPattern[f[x_]] :> 1, HoldPattern[g[x_]] :> 2, b -> 3};

Suppose we are only interesting in extracting information about f, in  
the way you originally wanted. This will do it:



Cases[h /. HoldPattern -> Hold, (Hold[f[x_]] :> y_) ->
    {x, y}, Infinity]


{{x_, 1}}



but this will do something rather different:



Cases[h, (x_ :> _) :> Level[x, -1]]


{{x, _, x_, 1}, {x, _, x_, 2}}



That's what I meant when I wrote "the most accurate way" - the way  
that will allow you to pick up exactly the pattern you want when  
similar ones are present.

Andrzej Kozlowski


On 27 Oct 2006, at 06:19, Bruce Colletti wrote:

> Andrezj
>
> Your reply, and that of another, has gripped and led me the  
> statement below (crafted with Wolfram Tech Support's help):
>
> Cases[h, (x_ :> _) :> Level[x, -1]]
>
> This is likewise appealing...but does it suffer a flaw not found in  
> your solutions?
>
> Thanks.
>
> Bruce
>
> =====================
> From: Andrzej Kozlowski <akoz at mimuw.edu.pl>
To: mathgroup at smc.vnet.net
> Subject: [mg70784] Re: [mg70759] DownValues and Cases
>
> (tm) Pro*
>
> On 26 Oct 2006, at 22:54, Andrzej Kozlowski wrote:
>
>>
>> On 26 Oct 2006, at 15:39, Bruce Colletti wrote:
>>
>>> Re Mathematica 5.2 under WinXP.
>>>
>>> The results of the first two Cases statements leads me to
>>> anticipate {{1,3.5}, {2,5}, {_,0}} as the output of the third.
>>>
>>> The output of the fourth Cases statement confirms this expectation.
>>>
>>> Unfortunately, the output of the third statement is the empty list.
>>>
>>> Why so?  I've reviewed a related mid-July MathGroup thread, but
>>> don't see the answer (if it's there at all).
>>>
>>> Thankx.
>>>
>>> Bruce
>>>
>>> --------------------------
>>>
>>> f at 1=3.5;
>>> f@2=5;
>>> f[_]:=0;
>>> h=DownValues@f
>>>
>>> Out[4]={HoldPattern[f[1]] :> 3.5, HoldPattern[f[2]] :> 5,
>>> HoldPattern[f[_]] :> 0}
>>>
>>> Cases[h,HoldPattern[f[x_]] -> x,Infinity]
>>> Out[5]={1,2,_}
>>>
>>> Cases[h,(_ :> y_) -> y,Infinity]
>>> Out[6]={3.5,5,0}
>>>
>>> Cases[h,(HoldPattern[f[x_]] :> y_) -> {x,y},Infinity]
>>> Out[7]={}
>>>
>>> Cases[{a :> 4,b :> 5, c :> 6},(x_ :> y_) -> {x,y}]
>>> Out[8]={{a,4},{b,5},{c,6}}
>>>
>>
>> This is rather tricky. The problem is how to force the
>> PatternMatcher to interpret HoldPattenr literally rather than as
>> the pattern to be held. Note that:
>>
>> Cases[h, (Verbatim[HoldPattern[f[2]]] :> y_) -> {x, y},
>>   Infinity]
>>
>> {{x, 5}}
>>
>> works, but:
>>
>>
>> Cases[h, (Verbatim[HoldPattern[f[x_]]] :> y_) -> {x, y},
>>   Infinity]
>>
>> {}
>>
>> doesn't, because now x_ is also interpreted literally rather than
>> as a pattern. So you have got to somehow to avoid using HoldPattern
>> directly in your pattern (this is now rally getting confusing), for
>> example like this:
>>
>>
>> Cases[h, (p_ :> y_) /; Head[p] === HoldPattern :>
>>    {p[[1,1]], y}, Infinity]
>>
>> {{1, 3.5}, {2, 5}, {_, 0}}
>>
>> There are probably more elegant ways but none comes to my mind just
>> now.
>>
>> Andrzej Kozlowski
>
>
> A more compact way to do the above is:
>
> Cases[h, (p_HoldPattern :> y_) :> {p[[1, 1]], y}, Infinity]
>
>
> But, it seems to me that the most accurate way to match expressions
> with Head HoldPattern, as you wanted to do, is to first replace
> HoldPattern by something like Hold or Unevaluated:
>
>
> Cases[h /. HoldPattern -> Hold,
>    (Hold[f[x_]] :> y_) -> {x, y}, Infinity]
>
>
> {{1, 3.5}, {2, 5}, {_, 0}}
>
>
> Andrzej Kozlowski
>


  • Prev by Date: Re: Re: DownValues and Cases
  • Next by Date: Re: DownValues and Cases
  • Previous by thread: Re: Re: DownValues and Cases
  • Next by thread: Re: DownValues and Cases