Performance of Java math code vs. Python

Question

Hello,
Not to spark a religious war, but I'm curious: The November 2008 issue of Linux Journal has an article about Scientific Computing. In it, the author demonstrates how to use Python for doing number crunching. He compared Python to C. So I want to compare Python to Java.
I did this: created a file called matrix.py . Its contents are:
import numpy
a1=numpy.empty((500,500))
a2=numpy.empty((500,500))
a3=a1*a2Then I ran it, by doing:
time python matrix.py...on multiple occasions. I'm doing this on a Fedora 9 machine and figure it will buffer the disk read of the python interpreter. Anyway, it finishes in about 0.18 seconds (realtime).
Subsequently, I created a similar piece of Java code:
public class Test {
     public static void main(String args[]) {
          long start=System.currentTimeMillis();
          double a1[][]=new double[500][500];
          double a2[][]=new double[500][500];
          double a3[][]=new double[500][500];
          int i, j, k;
          for (i=0; i<500; i++) {
               for (j=0; j<500; j++) {
                    a3[i][j]=0;
                    for (k=0; k<500; k++) {
                         a3[i][j] += a1[i][k] * a2[k][j];
          long end=System.currentTimeMillis();
          end = end - start;
          System.out.println("Duration: " + end);
}...For Java, I didn't use time(1) to time the run, rather I used System.out.println from within the code. This is because I don't use Python so I didn't want to spend the time to learn how to do the time math as I did above, and also I figure that in everyday use the load time of the JVM would incur a startup penalty which I didn't want to measure. In short, I deliberately put Python at a disadvantage because I'm lazy. I figured I could learn a little Python and correct the issue if necessary.
Turns out, it's not necessary, because the Java code takes 1.5 seconds! That's 8-9 times slower than Python on this multiplication problem. What gives? Is Java just that slow? I thought that by this day and age it would be fairly optimized...
Thanks for the cluestick, in advance... :-)
-Hushpuppy

Answer 1

Thanks mlk and sabre150. It turns out, numpy is an optimized math package. To really run a test, I'd have to compare numpy to say JScience (http://jscience.org/). So I'm comparing apples to oranges.
Anyway. Just for fun, I ran the code a few times so the JIT could do its thing. Doesn't seem to be doing a lot of optimization; my guess is there's not a lot more it could do. Here's what I got:
Output:
Duration: 1123
Duration: 1107
Duration: 1086
Duration: 1087
Duration: 1081
Duration: 1083
Duration: 1079
Duration: 1087
Duration: 1079
Duration: 1081Program:
public class Test {
     //double a1[][]=new double[500][500];
     //double a2[][]=new double[500][500];
     //double a3[][]=new double[500][500];
     static int a1[][]=new int[500][500];
     static int a2[][]=new int[500][500];
     static int a3[][]=new int[500][500];
     static long start;
     static long end;
     static int i, j, k;
     public static void multiply() {
          start=System.currentTimeMillis();
          for (i=0; i<500; i++) {
               for (j=0; j<500; j++) {
                    a3[i][j]=0;
                    for (k=0; k<500; k++) {
                         a3[i][j] += a1[i][k] * a2[k][j];
          end=System.currentTimeMillis();
          end = end - start;
          System.out.println("Duration: " + end);
     public static void main(String args[]) {
          int l;
          for (l=0; l<10; l++) {
               multiply();
}