Now for your plotting questions

How to produce vertical lines rather than a bunch of points like in the plot above?

&

Eric, the plot is really bad, since the aim is to produce vertical lines as the trend of data points suggests.

I'm guessing a bit at what you want. It seems like you want vertical lines rather than horizontal, and that's easy to do by just reversing the order of the coordinates. I see that you're trying variations of ListPlot and ListLinePlot, so I'm guessing that you want lines connecting the min & max values we already determined, and you probably want separate lines for each pair rather than connecting the whole series of data.

So, starting with where I left off before,

minMaxData = Merge[jgRootsAlt3, MinMax@*Flatten]
(* <|0.01->{0.316068,3.58297},0.21->{0.332205,17.5798},0.41->{0.347738,25.4253},0.61->{0.362734,31.6752},0.81->{0.37725,37.0623}|> *)

we now need to pair our x values, which are the keys of this association with each y value, which are the values of the association. An easy way is with KeyValueMap:

plotData = KeyValueMap[Thread@*List, minMaxData]
(* 
  {{{0.01,0.316068},{0.01,3.58297}},
   {{0.21,0.332205},{0.21,17.5798}},
   {{0.41,0.347738},{0.41,25.4253}},
   {{0.61,0.362734},{0.61,31.6752}},
   {{0.81,0.37725},{0.81,37.0623}}} 
*)

Now, most Plot functions can take multiple series of data (lists of lists), so we can actually just pass this directly to ListLinePlot and it'll create separate line plots for each pair.

ListLinePlot[plotData]

Now, you also tried some of the Log forms of these plots. Those should work exactly the same way, the output will just be scaled differently.

I'll stop there for now. Feel free to redirect if this isn't what you wanted. We can also tweak the display characteristics of the plots however you want.

Thank you very much! I cannot thank you enough.

I am learning a lot from discussions on the Wolfram community.

Hi, Eric! I am sending you my notebook (attached) that contains two questions. To be honest, I have attempted many times to get what I want and your help can illuminate my work. Thank you in advance for your help.

Attachments:

Example.nb

Here's some dummy data to make it easier to demonstrate (this would be just one set of results from SolveValues, i.e. the results where y=5):

data = {{72, 5}, {59, 5}, {38, 5}, {51, 5}, {55, 5}, {16, 5}, {93, 5}, {96, 5}, {67, 5}, {8, 5}}

To find the pair whose x value is largest:

MaximalBy[data, First]
(* {{96, 5}} *)

Notice that it's a list of pairs (just one pair in this case). That's because there may have been several pairs whose first element was the max.

I want to sort the elements in which x has the highest value for each value of y

Okay, if you want them sorted:

SortBy[data, First]
(* {{8, 5}, {16, 5}, {38, 5}, {51, 5}, {55, 5}, {59, 5}, {67, 5}, {72, 5}, {93, 5}, {96, 5}} *)

ReverseSortBy[data, First]
(* {{96, 5}, {93, 5}, {72, 5}, {67, 5}, {59, 5}, {55, 5}, {51, 5}, {38, 5}, {16, 5}, {8, 5}} *)

how to separate this list into two lists

Again, I don't understand this. What are the two lists you want?

I think maybe we've gotten too far away from your actual question. I suspect that you've tried to simplify your question, which is generally a good thing to do, but I fear we may be so far away from your actual need that you're doing a lot of unnecessary work.

To me, this is starting to sound like maybe you need some stronger structures to support some sort of analysis. Like, maybe you need associations. Starting with some dummy data and your data as pairs...

b1 = 5;
b2 = 10;
c1 = 7;
c2 = 14;
L1 = {{a1, c1}, {a1, b1}, {a2, b2}, {a2, c2}} (* I re-ordered so we can see how things change when we sort later *)

maybe we should add Association structure to it...

data1 = Merge[Rule @@@ L1, Identity]
(* <|a1 -> {7, 5}, a2 -> {10, 14}|> *)

Now you can do some queries or whatever. Since you're doing comparisons, you can sort this:

Sort /@ data1
(* <|a1 -> {5, 7}, a2 -> {10, 14}|> *)

Or if you knew you were going to need the data sorted, you could have done this when you created the association:

data2 = Merge[Rule @@@ L1, Sort]
(* <|a1 -> {5, 7}, a2 -> {10, 14}|> *)

Anyway, now we can split this data based on Min or Max:

Through[{Map[Min], Map[Max]}[data2]]
(* {<|a1 -> 5, a2 -> 10|>, <|a1 -> 7, a2 -> 14|>} *)

Anyway, this is all speculation. I don't really know how to answer your question, because it seems like it's missing important context.

Hi, Eric! I have the following list:

L1={{a1,b1},{a1,c1},{a2,b2},{a2,c2}}

I want to take the pair {a1,c1} rather than {a1,b1}, because c1>b1.

In other words, the result should be two lists L2 and L3 like:

L2={{a1,b1},{a2,b2}}

and

L3={{a1,c1},(a2,c2}}

I believe I should define a function for that, shouldn't I?

Thank you in advance for your response.

L1 = {a1, a2, a3};
L2 = {{{b1}, {b2}, {b3}}, {{c1}, {c2}, {c3}}};
Flatten[Map[Thread, Thread[{L1, Transpose[Flatten /@ L2]}]], 1]

This is getting a bit convoluted. There are probably better ways to manage your data structures elsewhere in your workflow.

Hi, Eric Rimbey! You are helping me a lot. Thank you. Can you help me again, please?

What if the result is like that:

{{{a1, {b1}}, {a1, {c1}}, {a2, {b2}}, {a2, {c2}}, {a3, {b3}}, {a3, {c3}}}

This is happening because L2 is like that:

L2={{{b1},{b2},{b3}},{{c1},{c2},{c3}}}

I realize that the command Flatten does not do what I want, which is that:

L2={{b1,b2,b3},{c1,c2,c3}} 

and also finally that

{{a1, b1}, {a1, c1}, {a2, b2}, {a2, c2}, {a3, b3}, {a3, c3}}

How would you deal with that?

Thank you in advance for your response and for your kind attention.

Eric, to be honest, I haven't understood clearly the following step:

Thread /@ Thread[{L1, Transpose[L2]}]

The shorthand /@ refers to the command Map. How would you write this step without the shorthand? Thank you for your patience with me.

Transpose just restructures things, it won't actually change the contents of the things. In your case, you need to duplicate some of the elements (e.g. you want a1 to appear in both {a1,b1} and {a1,c1}).

But we can work up to what you want (there are probably several other ways to do this):

Transpose[L2]
(* {{b1, c1}, {b2, c2}, {b3, c3}} *)

That kinda looks like it's going in the right direction. We just want to somehow "thread" the as through these.

Thread[{L1, Transpose[L2]}]
(* {{a1, {b1, c1}}, {a2, {b2, c2}}, {a3, {b3, c3}}} *)

Still headed in the right direction. What if we thread each of the three sublists?

Thread /@ Thread[{L1, Transpose[L2]}]
(* {{{a1, b1}, {a1, c1}}, {{a2, b2}, {a2, c2}}, {{a3, b3}, {a3, c3}}} *)

That's very close. We just need to remove a layer of List:

Flatten[Thread /@ Thread[{L1, Transpose[L2]}], 1]
(* {{a1, b1}, {a1, c1}, {a2, b2}, {a2, c2}, {a3, b3}, {a3, c3}} *)

Bingo!

You could use Condition:

G[y_] := 10*y;
F[x_, y_] := x^2 + y /; G[y] >= 2000
F[x_, y_] := -(x + y) /; G[y] < 2000

(I simplified the functions for clarity.)

F[1, 1]
(* -2 *)

F[1, 2000]
(* 2001 *)

F1[x_,y_]:=x*y
F2[x_,y_]:=x/y
G[x_,y_]:=x-y
F[x_,y_]:=Which[G[x,y]>20,F1[x,y],G[x,y]<20,F2[x,y]]

Then

F[40,10]

returns 400 and

F[40,30]

returns

4/3