MathGroup Archive 2010

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

Search the Archive

Re: find index in an array

  • To: mathgroup at smc.vnet.net
  • Subject: [mg108145] Re: [mg108104] find index in an array
  • From: Leonid Shifrin <lshifr at gmail.com>
  • Date: Tue, 9 Mar 2010 06:22:51 -0500 (EST)
  • References: <201003081115.GAA04103@smc.vnet.net>

Hi Daniel,

converting logical condition to a pattern for Position is really easy - use
either PatternTest (?) or Condition (/;):

In[106]:=
a = {{{0.08896779137, 0.08522648397}, {0.1162297255,
     0.4316697935}}, {{0.6409512512, 0.3506400003}, {0.1156346501,
     0.9537010025}}, {{0.8820963106, 0.9962655552}, {0.004333293427,
     0.727745896}}};

In[110]:= Position[a, _?(0.3 < # < 0.7 &)]

Out[110]= {{1, 2, 2}, {2, 1, 1}, {2, 1, 2}}

In[111]:= Position[a, x_ /; 0.3 < x < 0.7]

Out[111]= {{1, 2, 2}, {2, 1, 1}, {2, 1, 2}}

It's as simple as that, and can be extended just as easily to conditions of
pretty much any complexity.

Regards,
Leonid


On Mon, Mar 8, 2010 at 3:15 AM, Daniel Flatin <dflatin at rcn.com> wrote:

> I work in an environment where another system is the dominant analysis
> tool. In
> porting some code to my preferred work environment, Mathematica, I find
> that I occasionally need to reinvent functionality found in the other
> system. One
> such function is find(). In that system, this function returns all the
> non-zero indices in an array. Usually, this test array is the
> consequence of a logical operation on each element, so that in the that
> system
>
> indx == find(A > 3);
>
> returns all the indices for which elements of A are greater than 3. I
> have replicated this functionality in Mathematica, and I wanted to both
> share it, and maybe get some input in how I could make it more
> efficient or more elegant. One of the ways I learn to program in
> Mathematica is to analyze all the various responses to simple questions
> here, and I am hoping to steer the process here.
>
> Here is my function:
>
> findIndex[ array_?ArrayQ, test_ ] :== Module[
>  {n==Length[Dimensions[array]],idx},
>  idx == Cases[MapIndexed[If[test[#1],#2]&,array,{n}],{__Integer},n];
>  If[n====1,Flatten[idx],idx]
> ]
>
> example:
>
> (* set a *)
>
> a ==
>
> {{{0.08896779137,0.08522648397},{0.1162297255,0.4316697935}},{{0.6409512512,0.3506400003},{0.1156346501,0.9537010025}},{{0.8820963106,0.9962655552},{0.004333293427,0.727745896}}};
>
> (*
>
> get indices *)
>
> indx == findIndex[a, 0.3 < # < 0.7&]
>
> output:
>
> {{1, 2, 2}, {2, 1, 1}, {2, 1, 2}}
>
> and to verify this is a valid result:
>
> Extract[a,indx]
>
> returns
>
> {0.4316697935,0.6409512512,0.3506400003}
>
> as does
>
> Select[Flatten[a], 0.3 < # < 0.7&]
>
> Note that this function is quite a bit like Position[] except that it
> works on results of a logical comparison rather than a pattern.
> Position, on the other hand, has some a feature I view as a virtue. It
> can operate on non-array objects, in fact, it can operate on non-list
> objects.
>
> If any readers has some insight into a more compact, elegant, or
> Mathematica-like approach to this findIndex function, please feel free
> to respond.
>
> Anyway, thanks for your time, and in advance for your thoughts.
> Dan
>
>



  • Prev by Date: Re: Mathieu function zeros
  • Next by Date: Re: Conjugate of symbolic expressions
  • Previous by thread: Re: find index in an array
  • Next by thread: Re: find index in an array