The slow part is the eval, because each time it is called, it has to be parsed and compiled again and again.
So I looked at ways to avoid this, by compiling once and calling the compiled code. At the end, I even avoided repeated calls to the JS engine, by passing it arrays back and forth. Here are my little experiments, with kind of micro benchmarks, not the most reliable, but perhaps giving an idea of each overhead.

1. import javax.script.ScriptEngine;
2. import javax.script.ScriptEngineManager;
3. import javax.script.ScriptException;
4. import javax.script.Invocable;
5.  
6. ScriptEngine jsEngine;
7.  
8. final String FUNC = "Math.sin(x) + Math.cos(x)";
9. final String FUNCTION = "function compute(x) { return " + FUNC + "; }";
10.  
11. final String OBJ = "var obj = new Object(); obj.compute = function (x) { return " + FUNC + "; }";
12. Object method;
13.  
14. final int TEST_NB = 6;
15.  
16. void setup()
17. {
18.   size(500, 500);
19.   background(255);
20.   strokeWeight(3);
21.  
22.   ScriptEngineManager mgr = new ScriptEngineManager();
23.   jsEngine = mgr.getEngineByName("JavaScript");
24.  
25.   long t1 = System.currentTimeMillis();
26.   stroke(#FF0000);
27.   for (int x = 0; x < width; x++)
28.   {
29.     double y = getYEval(x / TWO_PI);
30.     point((float) x, (float) (1 * height / TEST_NB + y * height / 16));
31.   }
32.   println("Eval: " + (System.currentTimeMillis() - t1));
33.  
34.   t1 = System.currentTimeMillis();
35.   eval(FUNCTION);
36.   stroke(#0000FF);
37.   for (int x = 0; x < width; x++)
38.   {
39.     double y = getYInvokeF(x / TWO_PI);
40.     point((float) x, (float) (2 * height / TEST_NB + y * height / 16));
41.   }
42.   println("Invoke function: " + (System.currentTimeMillis() - t1));
43.  
44.   t1 = System.currentTimeMillis();
45.   eval(OBJ);
46.   method = jsEngine.get("obj");
47.   stroke(#00FF00);
48.   for (int x = 0; x < width; x++)
49.   {
50.     double y = getYInvokeM(x / TWO_PI);
51.     point((float) x, (float) (3 * height / TEST_NB + y * height / 16));
52.   }
53.   println("Invoke method: " + (System.currentTimeMillis() - t1));
54.  
55.   t1 = System.currentTimeMillis();
56.   stroke(#FFFF00);
57.   eval(
58.     "var a = java.lang.reflect.Array.newInstance(java.lang.Double, " + width + ");\n" +
59.     "for (var i = 0; i < a.length; i++) { var x = i / 6.28; a[i] = " + FUNC + "; }"
60.   );
61.   Double[] r1 = (Double[]) jsEngine.get("a");
62. //  println(r);
63.   for (int x = 0; x < width; x++)
64.   {
65.     double y = r1[x];
66.     point((float) x, (float) (4 * height / TEST_NB + y * height / 16));
67.   }
68.   println("Function with one array: " + (System.currentTimeMillis() - t1));
69.  
70.   t1 = System.currentTimeMillis();
71.   stroke(#FF00FF);
72.   double[] data = new double[width];
73.   for (int x = 0; x < width; x++)
74.   {
75.     data[x] = x / TWO_PI; // Can be more arbitrary
76.   }
77.   jsEngine.put("data", data);
78.   eval(
79.     "var a = java.lang.reflect.Array.newInstance(java.lang.Double, " + width + ");\n" +
80.     "for (var i = 0; i < a.length; i++) { var x = data[i]; a[i] = " + FUNC + "; }"
81.   );
82.   Double[] r2 = (Double[]) jsEngine.get("a");
83. //  println(r);
84.   for (int x = 0; x < width; x++)
85.   {
86.     double y = r2[x];
87.     point((float) x, (float) (5 * height / TEST_NB + y * height / 16));
88.   }
89.   println("Function with two arrays: " + (System.currentTimeMillis() - t1));
90. }
91.  
92. double getYEval(double x)
93. {
94.   try
95.   {
96.     String expr = "var x = " + x + "; " + FUNC;
97.     return ((Double) jsEngine.eval(expr)).doubleValue();
98.   }
99.   catch (ScriptException ex)
100.   {
101.     ex.printStackTrace();
102.   }
103.   return 0;
104. }
105.  
106. double getYInvokeF(double x)
107. {
108.   try
109.   {
110.     return ((Double) ((Invocable) jsEngine).invokeFunction("compute", Double.valueOf(x))).doubleValue();
111.   }
112.   catch (ScriptException se)
113.   {
114.     se.printStackTrace();
115.   }
116.   catch (NoSuchMethodException nsme)
117.   {
118.     nsme.printStackTrace();
119.   }
120.   return 0;
121. }
122.  
123. double getYInvokeM(double x)
124. {
125.   try
126.   {
127.     return ((Double) ((Invocable) jsEngine).invokeMethod(method, "compute", Double.valueOf(x))).doubleValue();
128.   }
129.   catch (ScriptException se)
130.   {
131.     se.printStackTrace();
132.   }
133.   catch (NoSuchMethodException nsme)
134.   {
135.     nsme.printStackTrace();
136.   }
137.   return 0;
138. }
139.  
140. Object eval(String toEval)
141. {
142.   try
143.   {
144.     return jsEngine.eval(toEval);
145.   }
146.   catch (ScriptException se)
147.   {
148.     se.printStackTrace();
149.   }
150.   return null;
151. }

The results:
Eval: 202
Invoke function: 50
Invoke method: 37
Function with one array: 20
Function with two arrays: 13

Spectacular gains, no?