Here's an alternative backwards for loop which spends a tiny bit less time checking and updating:

void arrayAdd(  float[] a, float[] b, float[] out ) {
  for ( int i=a.length; i!=0; out[--i] = a[i] + b[i] );
}

void arrayMult( float[] a, float[] b, float[] out ) {
  for ( int i=a.length; i!=0; out[--i] = a[i] * b[i] );
}

I can't promise this will be faster than what you have already but I combined the GoToLoop's code with reflection to create a very neat solution.

I would be very interested in how this compares with the other methods you have tried.

1. import java.lang.reflect.Method;
2. 
   
3. float [] a, b, out;
4. int n = 100000000;
5. Method add, mult;
6. 
   
7. public void setup() {
8.   a = new float[n];
9.   b = new float[n];
10.   out = new float[n];
11.   for (int i = 0; i < n; i++) {
12.     a[i] = random(10.0f, 20.0f);
13.     b[i] = random(1.0f, 2.0f);
14.   }
15.   // Find the methods once
16.   if (!setupMethods()) {
17.     println("Unable to find functions - program will Terminate");
18.     System.exit(1);
19.   }
20.   // Then we can use them whenever we want to :-)
    
21.   executeMethod(add, a, b, out);
22.   executeMethod(mult, a, b, out);
23. }
24. 
    
25. public boolean executeMethod(Method m, float[] a0, float[] a1, float[] r) {
26.   try {
27.     long t = System.nanoTime();
28.     m.invoke(null, a0, a1, r);
29.     t = System.nanoTime() - t;
30.     println("Method " + m.getName() + " took " + t + "ns to execute");
31.   }
32.   catch (Exception e) {
33.     return false;
34.   }
35.   return true;
36. }
37. 
    
38. /*
39.  * Locate the named methods we have created in the Functions class
40.  */
41. public boolean setupMethods() {
42.   String mname = "";
43.   try {
44.     mname = "add";
45.     add = Functions.class.getDeclaredMethod("arrayAdd", new Class[] { float[].class, float[].class, float[].class } );
46.     mname = "mult";
47.     mult = Functions.class.getDeclaredMethod("arrayMult", new Class[] { float[].class, float[].class, float[].class } );
48.   }
49.   catch (NoSuchMethodException e) {
50.     println("Unable to find "+ mname + " method");
51.     return false;
52.   }
53.   catch (SecurityException e) {
54.     println("Unable to use "+ mname + " method (Java Security)");
55.     return false;
56.   }
57.   return true;
58. }
59. 
    
60. public static class Functions {
61.   public static void arrayAdd( float[] a, float[] b, float[] out ) {
62.     for ( int i=a.length; i!=0; out[--i] = a[i] + b[i] );
63.   }
64.   public static void arrayMult( float[] a, float[] b, float[] out ) {
65.     for ( int i=a.length; i!=0; out[--i] = a[i] * b[i] );
66.   }
67. }

quarks > 

If you want to work at the element level then it is possible I have modified your code to make it work. But I suspect that at the element level the timings would be worse than when done at the array level.

You will see that float.class is acceptable and use invoke to execute a method that returns a vakue. Invoke returns an object that must be cast to the appropriate type.

You might not be familiar with Java Reflection but it is incredibly powerful (plus it's fun to play with) and makes all sorts of things possible.

Anyway here is the code for the element level

1. import java.lang.reflect.Method;
2. 
   
3. public static class Functions {
4.   public static float Add (float a, float b) {
5.     return a+b;
6.   }
7.   public static float Mult(float a, float b) {
8.     return a*b;
9.   }
10. }
11. 
    
12. void arrayOpRF( float [] a, float [] b, float [] out, Method func ) {
13.   for (int i=0; i<out.length; i++) {
14.     try {   
15.       out[i] = (Float)func.invoke(func, a[i], b[i]);
16.     }
17.     catch(Exception e) {
18.     }
19.   }
20. }
21. 
    
22. float [] a, b, out;
23. int  n = 3;
24. 
    
25. void setup() {
26.   a = new float[n];
27.   b = new float[n];
28.   out = new float[n];
29.   for(int i = 0; i < n; i++){
30.     a[i] = random(2,10);
31.     b[i] = random(2,10);
32.   }
33.    
34.   Class[] args = new Class[] {
35.     float.class, float.class
36.   };
37.   Method func = null;
38.   try {
39.     func = Functions.class.getDeclaredMethod("Add", args );
40.   }
41.   catch(Exception e) {
42.   }
43.   arrayOpRF( a, b, out, func ) ;
44.   for(int i = 0; i < n; i++){
45.     println(a[i] + "\t" + b[i] + "\t" + out[i]);
46.   }
47. }

Here's my own experiments w/ caching iterators & backwards loops.

Although         -> for ( int i=a. length; i!=0;         out[--i] = a[i] * b[i] );
is faster than   -> for ( int i=0; i<a. length; i++ )  out[i]   = a[i] * b[i];

However          -> for ( int i=a. length; i!=0;         out[--i] = func.eval(a[i], b[i]) );
is slower than  -> for ( int i=0, ii=a. length; i!=ii;  out[i]   = func.eval(a[i], b[i++]) );

Seems like backwards loops are better for pure calc,
and forward loops for function calls!

Anyways, here's my alternative version:

1. /**
2.  * Function Pass Speed Test (v2.0)
3.  * by Prokop Hapala (2013/Jan)
4.  *
5.  * http://forum.processing.org/topic/pass-function-in-other-function-fast
6.  */
7.  
8. final static int m = 30, n = 10000000, nm = n*m;
9. float t1, t2;
10.  
11. final static float[] a = new float[n];
12. final static float[] b = new float[n];
13. final static float[] o = new float[n];
14.  
15. void setup() {
16.  
17.   /*
18.   for (int i = 0; i < n; i++) {
19.    a[i] = random(10f, 20f);
20.    b[i] = random(1f, 2f);
21.    }
22.    */
23.  
24.   t1 = millis();
25.   //for (int i=0; i<m; i++) arrayAdd( a,b, out );
26.   for ( int i=0; i<m; i++ )    arrayMult( a, b, o );
27.   t2 = millis() - t1;
28.   println( "Static:       "+ nm +" [ops]   \t"+ t2 +"  [s]  \t"+ 1000000*t2/nm +"  [ns/op] " );
29.  
30.   t1 = millis();
31.   //for (int i=0; i<m; i++) arrayAdd_Alt( a,b, out );
32.   for ( int i=0; i<m; i++ )    arrayMult_Alt( a, b, o );
33.   t2 = millis() - t1;
34.   println( "Static_Alt:   "+ nm +" [ops]   \t"+ t2 +"  [s]  \t"+ 1000000*t2/nm +"  [ns/op] " );
35.  
36.   t1 = millis();
37.   //Function func = new FAdd();
38.   Function func = new FMult();
39.   for ( int i=0; i<m; i++ )    arrayOp( a, b, o, func );
40.   t2 = millis() - t1;
41.   println( "Dynamic:      "+ nm +" [ops]   \t"+ t2 +"  [s]  \t"+  1000000*t2/nm +" [ns/op] " );
42.  
43.   t1 = millis();
44.   for ( int i=0; i<m; i++ )    arrayOp_Alt( a, b, o, func );
45.   t2 = millis() - t1;
46.   println( "Dynamic_Alt:  "+ nm +" [ops]   \t"+ t2 +"  [s]  \t"+  1000000*t2/nm +" [ns/op] " );
47.  
48.   exit();
49. }

1. void arrayAdd(  float[] a, float[] b, float[] out ) {
2.   for (int i=0; i<a.length; i++)   out[i] = a[i] + b[i];
3. }
4.  
5. void arrayMult( float[] a, float[] b, float[] out ) {
6.   for (int i=0; i<a.length; i++)   out[i] = a[i] * b[i];
7. }
8. //************************************************************/
9. void arrayAdd_Alt(  float[] a, float[] b, float[] out ) {
10.   for ( int i=a.length; i!=0; out[--i] = a[i] + b[i] );
11. }
12.  
13. void arrayMult_Alt( float[] a, float[] b, float[] out ) {
14.   for ( int i=a.length; i!=0; out[--i] = a[i] * b[i] );
15. }
16. /*
17. void arrayAdd_Alt(  float[] a, float[] b, float[] out ) {
18.   for ( int i=0, ii=a.length; i!=ii; out[i] = a[i] + b[i++] );
19. }
20.  
21. void arrayMult_Alt( float[] a, float[] b, float[] out ) {
22.   for ( int i=0, ii=a.length; i!=ii; out[i] = a[i] * b[i++] );
23. }
24. */

1. class Function {
2.   float eval(float a, float b) {
3.     return Float.NaN;
4.   }
5. }
6.  
7. class FAdd extends Function {
8.   float eval(float a, float b) {
9.     return a+b;
10.   }
11. }
12.  
13. class FMult extends Function {
14.   float eval(float a, float b) {
15.     return a*b;
16.   }
17. }
18.  
19. void arrayOp( float[] a, float[] b, float[] out, Function func ) {
20.   for (int i=0; i<a.length; i++)    out[i] = func.eval( a[i], b[i] );
21. }
22. //************************************************************/
23. /*
24. void arrayOp_Alt( float[] a, float[] b, float[] out, Function func ) {
25.  for ( int i=a.length; i!=0; out[--i] = func.eval(a[i], b[i]) );
26.  }
27.  */
28.  
29. void arrayOp_Alt( float[] a, float[] b, float[] out, Function func ) {
30.   for ( int i=0, ii=a.length; i!=ii; out[i] = func.eval(a[i], b[i++]) );
31. }

I have combined the code from my two previous posts so I can use reflection to call

1. to a single function by name that either adds or multiplies the whole array
2. a single function that adds or multiplies a single float which is then called for each element of the array

The results for a 10 million element array are
Method arrayAdd took     19992511 ns to execute
Method arrayMult took    19207900 ns to execute
Method elementAdd took  363502679 ns to execute
Method elementMult took 339163666 ns to execute

It seems that going by element was slower by a factor of 18 (approx)

Here is the code for you to try.

1. import java.lang.reflect.Method;
2. float [] a, b, out;
3. int n = 10000000;
4. Method addArrays, multArrays;
5. Method addElement, multElement;
6. 
   
7. public void setup() {
8.   a = new float[n];
9.   b = new float[n];
10.   out = new float[n];
11.   for (int i = 0; i < n; i++) {
12.     a[i] = random(10.0f, 20.0f);
13.     b[i] = random(1.0f, 2.0f);
14.   }
15.   // Find the methods once
16.   if (!setupMethods()) {
17.     println("Unable to find functions - program will Terminate");
18.     System.exit(1);
19.   }
20.   // Then we can use them many times.
21.   executeArrayMethod(addArrays, a, b, out);
22.   executeArrayMethod(multArrays, a, b, out);
23.   executeElementMethod(addElement, a, b, out);
24.   executeElementMethod(multElement, a, b, out);
25. }
26. 
    
27. // Execute a named method that processes the entire array
28. public boolean executeArrayMethod(Method m, float[] a0, float[] a1, float[] r) {
29.   try {
30.     long t = System.nanoTime();
31.     m.invoke(null, a0, a1, r);
32.     t = System.nanoTime() - t;
33.     println("Method " + m.getName() + " took " + t + " ns to execute");
34.   }
35.   catch (Exception e) {
36.     return false;
37.   }
38.   return true;
39. }
40. 
    
41. // this will execute the named method on each element of the array
    
42. public boolean executeElementMethod(Method m, float[] a0, float[] a1, float[] r) {
43.   try {
44.     long t = System.nanoTime();
45.     for ( int i=a.length; i!=0; out[--i] = (Float) m.invoke(null, a0[i], a1[i]));
46.     t = System.nanoTime() - t;
47.     println("Method " + m.getName() + " took " + t + " ns to execute");
48.   }
49.   catch (Exception e) {
50.     return false;
51.   }
52.   return true;
53. }
54. 
    
55. /*
56.  * Locate the named methods that have been
57.  */
58. public boolean setupMethods() {
59.   String mname = "";
60.   try {
61.     mname = "arrayAdd";
62.     addArrays = Functions.class.getDeclaredMethod(mname, new Class[] {
63.       float[].class, float[].class, float[].class
64.     }
65.     );
66.     mname = "arrayMult";
67.     multArrays = Functions.class.getDeclaredMethod(mname, new Class[] {
68.       float[].class, float[].class, float[].class
69.     }
70.     );
71.     mname = "elementAdd";
72.     addElement = Functions.class.getDeclaredMethod(mname, new Class[] {
73.       float.class, float.class
74.     }
75.     );
76.     mname = "elementMult";
77.     multElement = Functions.class.getDeclaredMethod(mname, new Class[] {
78.       float.class, float.class
79.     }
80.     );
81.   }
82.   catch (NoSuchMethodException e) {
83.     println("Unable to find "+ mname + " method");
84.     return false;
85.   }
86.   catch (SecurityException e) {
87.     println("Unable to use "+ mname + " method (Java Security)");
88.     return false;
89.   }
90.   return true;
91. }
92. 
    
93. public static class Functions {
94.   public static void arrayAdd( float[] a, float[] b, float[] out ) {
95.     for ( int i=a.length; i!=0; out[--i] = a[i] + b[i] );
96.   }
97.   public static void arrayMult( float[] a, float[] b, float[] out ) {
98.     for ( int i=a.length; i!=0; out[--i] = a[i] * b[i] );
99.   }
100.   public static float elementAdd (float a, float b) {
101.     return a+b;
102.   }
103.   public static float elementMult(float a, float b) {
104.     return a*b;
105.   }
106. }

I have extended the above example to compare using reflection with polymorphism (i.e. the dynamic version you first posted).

I got these results (array size 10 million)

1. Method arrayAdd took       19387559 ns to execute
2. Method arrayMult took      19300419 ns to execute
3. Method elementAdd took    427215024 ns to execute
4. Method elementMult took   354540463 ns to execute
5. Object AddObject took      24621944 ns to execute
6. Object MultObject took     38974246 ns to execute

1-4 use reflection and 5-6 use polymorphism.

Although 1/2 gave the best results this is not surprising since it proccessed the whole array without further functions calls.
The last 4 results are more interesting since the function call is for each element and it shows clearly that polymorphism is preferable to using reflection.

If you want the code to try on your machine just say and I will post it here.