Plotting the components of a function that returns a list in different colors without redundant evaluations of the function

Question

I have a function f which takes a number as input, and returns a list of numbers (the length of the list is constant). f is hard to calculate (each evaluation takes a long time).

I want to plot the different components of f in different colors.

If I use this command:

Plot[f[x], {x, -2, 2}]

all the lines are drawn in the same color.
If I use this command:

Plot[{f[x][[1]], f[x][[2]], f[x][[3]]}, {x, -2, 2}]

(assuming the list has three components) the lines are drawn in different colors, but the function is called three times the necessary amount.

Note that this is a numeric function, it cannot be evaluated with a symbolic argument (i.e. the function definition begins with f[x_Real]:=), so there is no use in using Evaluate like in this question.

Answer 1

At risk of stating the obvious, if you are willing to give up the adaptive sampling, exclusions, etc. of Plot you could use ListLinePlot:

f[x_?NumericQ] := x + Mod[x, {1, 2, 3}]

ListLinePlot[Transpose@Table[f[x], {x, 0, 10, 0.01}], PlotStyle -> Thick] 

---

Better I think is to restyle the Graphics data produced by plot, as Heike did for Plotting piecewise function with distinct colors in each section and which I refactored in my answer. Applied here:

Module[{i = 1},
  Plot[f[x], {x, 0, 10}, PlotStyle -> Thick] /.
    x_Line :> {ColorData[1][i++], x}
]

---

Even nicer is Simon Woods' method which styles the plot while it is created, posted in answer to:

• All curves in plot have the same style. Cannot be fixed with Evaluate[]

Also useful and very interesting is the solution by wxffles in the follow-up question:

• An elegant way to plot a numeric function that returns a list, and have each element in a different color

Answer 2

Please consider the following simple example

i = 0;
f[x_?NumericQ] := {x^2, 2 x^2, x^2 + 1};
Plot[f[x], {x, 0, 1}, EvaluationMonitor :> i++];
i

(* Out[30]= 471 *)

and now the same code for only the first component of f

i = 0;
Plot[x^2, {x, 0, 1}, EvaluationMonitor :> i++];
i

(* Out[33]= 157 *)

If you now recall, that $3\cdot 157 = 471$ you see that even in your Plot[f[x],...] call the function is called more often than one would naively expect. Therefore, I claim you can skip hard thinking about this issue.

Answer 3

You could memoize the function:

f[x_] := f[x] = x + Mod[x, {1, 2, 3}]

Plot[{f[x][[1]], f[x][[2]], f[x][[3]]}, {x, 0, 10}, PlotStyle -> Thick]

If you don't want to use memory globally for this or memoize for all calls to f you could make a copy:

Module[{g},
  g[x_] := g[x] = f[x];
  Plot[{g[x][[1]], g[x][[2]], g[x][[3]]}, {x, 0, 10}, PlotStyle -> Thick]
]

Answer 4

If your functions are continuous, you may use something like (naive example follows):

f[x_Real] := {2 x, 3 x};
Plot[f[x], {x, -2, 2}] /. {Hue[x__], Line[y__], Line[z__]} -> {Hue[x],
    Line[y], Hue[0, 1, 1], Line[z]}