I have the minimum Y value. I want to find the corresponding X value from the list

Question

I have a very big file and contains data in the format of {x,y}. I got the minimum Y value by using

data[[All, 2]] // Min[#] &

Now I want to get the X value corresponding to the minimum Y value. How can I get it? Thanks a lot for your help ..!

@MarcoB Wouldn't Sort take much more time in general case? — BlacKow, Jun 22 '15 at 20:34
@BlacKow that's an interesting point. I ran some timings and I posted them as an answer, since it was too long for a comment. — MarcoB, Jun 22 '15 at 20:49
Thank you very much. Really both are working as I newbee in mathematica I did not find any differecnes on their performance. — Sushanta, Jun 22 '15 at 21:08
This question has been asked and answered many times before, both for the case of a single value and multiple values, and for both minimum and maximum values. (Though understanding one should give one a solution to the other.) Unfortunately I can only pick one duplicate so I chose the one with the lowest post ID. See comment below for more related questions. — Mr.Wizard, Jun 23 '15 at 10:24
Related: (1342), (2177), (2434), (7679), (10143), (19300), (31385), (31878), (37594) — Mr.Wizard, Jun 23 '15 at 10:25

score 17 · Answer 1 · edited Jun 23 '15 at 02:49

17

One solution that is three to four times as fast as the fastest solution so far (halirutan's compiled Do loop) is:

data[[Ordering[data[[All, 2]], 1], 1]]

The obligatory timings:

MinimalBy[data, Last][[1, 1]] // RepeatedTiming
SortBy[data, Last][[1, 1]] // RepeatedTiming
SortBy[data, {Last}][[1, 1]] // RepeatedTiming
TakeSmallestBy[data, Last, 1][[1, 1]] // RepeatedTiming
minByLast[data] // RepeatedTiming
data[[Ordering[data[[All, 2]], 1], 1]] // RepeatedTiming

Output for random seed 5:

{2.0, 362.181}
{0.53, 362.181}
{0.49, 362.181}
{0.756, 362.181}
{0.12, 362.181}
{0.04, {362.181}}

Random seed 42:

{1.7, 375.714}
{0.50, 375.714}
{0.46, 375.714}
{0.78, 375.714}
{0.12, 375.714}
{0.032, {375.714}}

I note that even if you compile halirutan's code with CompilationTarget->"C" Ordering is still almost twice as fast.

edited Jun 23 '15 at 02:49

xyz

605
4
38
117

answered Jun 22 '15 at 21:28

Sjoerd C. de Vries

65,815
14
188
323

Ordering[#,1] is probably treated as special case, because data[[Ordering[data[[All, 2]], 2], 1]] is almost 10 times slower... – BlacKow Jun 22 '15 at 21:40
That was my first thought, but I dropped it without testing because we need to compare the last elements. My thought was that this makes it slower. It seems my decision was premature. +1 – halirutan Jun 22 '15 at 21:43
@BlacKow Ordering[#,1] can be seen as the first stage in an unfinished sort. Ordering[#,2] is a successive stage, so necessarily must be slower. – Sjoerd C. de Vries Jun 22 '15 at 21:44
@SjoerdC.deVries Is it documented anywhere what sorting algorithm is used? – BlacKow Jun 22 '15 at 21:48
It should be something like data[[Ordering[data[[All, 2]], 1], 1]][[1]] or data[[Sequence @@ Ordering[data[[All, 2]], 1], 1]] to get the same output format (without the List) as the other methods. – Karsten7 Jun 22 '15 at 22:06
@BlacKow I don't know where this is documented, though I seem to remember having read about this somewhere. – Sjoerd C. de Vries Jun 23 '15 at 05:59

score 13 · Answer 2 · answered Jun 22 '15 at 21:06

13

As it seem a compiled stupid Do loop is a viable alternative and still the fastest on my machine:

minByLast = Compile[{{data, _Real, 2}},
  Module[{min = First[data]},
   Do[
    If[Last[min] > Last[d], min = d], {d, data}];
   First[min]
   ]
  ]

And in comparison with the methods proposed it still seems to win

SeedRandom[5]
data = RandomReal[1000, {2000000, 2}];

MinimalBy[data, Last][[1, 1]] // RepeatedTiming
SortBy[data, Last][[1, 1]] // RepeatedTiming
SortBy[data, {Last}][[1, 1]] // RepeatedTiming
TakeSmallestBy[data, Last, 1][[1, 1]] // RepeatedTiming
minByLast[data] // RepeatedTiming

answered Jun 22 '15 at 21:06

halirutan

112,764
7
263
474

1

I can understand how your compiled version is the fastest. But how non-compiled SortBy is faster than non-compiled MinimalBy is beyond me... – BlacKow Jun 22 '15 at 21:14
1

@BlacKow I think it is even worse with the new TakeSmallestBy function which should outperform all other solutions, because it is specifically made for, well, taking the smallest element from a list.. – halirutan Jun 22 '15 at 21:19
Your minByLast is the fasted even when the time needed by Compile is included in the timing measurement. – Karsten7 Jun 22 '15 at 21:21

score 9 · Answer 3 · answered Jun 22 '15 at 20:48

9

@BlackKow raised an interesting point about speed of the two solutions we proposed in comments. Out of curiosity I timed the two solutions on a random data set:

SeedRandom[5]
data = RandomReal[1000, {2000000, 2}];

MinimalBy[data, Last] // RepeatedTiming
SortBy[data, Last][[1, 1]] // RepeatedTiming
SortBy[data, {Last}][[1, 1]] // RepeatedTiming

(* Out:
{1.68, {{362.181, 0.000374484}}}
{0.507, 362.181}
{0.473, 362.181}
*)

It seems that SortBy is still faster than MinimalBy. The stable sort version (third option) is slightly faster still, since it doesn't go into breaking ties after the sort-by-last has been completed.

answered Jun 22 '15 at 20:48

MarcoB

67,153
18
91
189

Whaaat? How this can be true? Care to share insights why? MinimalBy should take O(N)... – BlacKow Jun 22 '15 at 20:56
TakeSmallestBy[data, Last, 1] – chuy Jun 22 '15 at 20:58
3

@chuy I have to say it is embarrassing that a function like TakeSmallestBy, introduced in version 10.1 is twice as slow as a SortBy and 4x slower than a simple Do loop written in less than a minute. This makes such things nothing more then syntactic sugar. – halirutan Jun 22 '15 at 21:17
1

@halirutan I can't disagree that it should be the fastest. – chuy Jun 22 '15 at 21:20

Michael E2 · Answer 4 · 2015-06-22T23:54:50.100

6

My ~~two~~ one candidate:

SeedRandom[5]
data = RandomReal[1000, {2000000, 2}];

(* First@Extract[data, Ordering[data[[All, 2]], 1]] // RepeatedTiming *) (* Sjoerd's *)
First@Nearest[#2 -> #1, Min[#2]] & @@ Transpose[data] // RepeatedTiming
(*
  {0.038, 362.181}  (* Didnt' read Sjoerd's answer carefully enough first *)
  {0.029, 362.181}
*)

Sorry about that Sjoerd!

edited Jun 22 '15 at 23:54

answered Jun 22 '15 at 23:48

Michael E2

235,386
17
334
747

1

Nearest was improved in V10.1. – Michael E2 Jun 23 '15 at 01:22
No problem, and Nearest has become very fast indeed. In v9 the same code is almost 20 times slower. +1 – Sjoerd C. de Vries Jun 23 '15 at 09:46
I closed this question because it has been asked in various forms many times. (See links above.) We now how many good answers scattered around the site. I wonder if this method would be better posted in an older Q&A? – Mr.Wizard Jun 23 '15 at 10:32
@Mr.Wizard Thanks. Nearest isn't as fast as Pick in the two closest questions, http://mathematica.stackexchange.com/q/10143 and http://mathematica.stackexchange.com/q/900. And, to my mind, Pick seems clearer. (I answered one question with this method, but just checked, and Pick is faster under certain conditions.) If you think I should add it to another question (of the two I mentioned, say), please suggest it and I will do it. – Michael E2 Jun 23 '15 at 22:48

I have the minimum Y value. I want to find the corresponding X value from the list

4 Answers4

Linked