Timings, best of 3, seconds:
  ao_d, float:                  3.67
  ao_c with gcc-llvm, float:    3.72
  ao_c with gcc-llvm, double:   3.83
  ao_c with gcc, double:        3.99
  ao_c with gcc, float:         4.04
  ao_d, double:                 4.10
  AO.java, float, naive:        6.35
  ao2_py with Psyco:           16.72
  ao3_d, float, naive:         24.09
  ao_py with Psyco:            29.75
  ao2_d, float, naive:         31.62
  ao_py with ShedSkin          48.58
  ao2_py without Psyco:        70.6
  ao_py without Psyco:        138.46

Timings on Pubuntu:
  ao1_d:             2.95
  ao_c, gcc, float:  3.82
  ao3_d:             8.78 (BUG)
  ao2_d:            16.52 (BUG)

Timings on Pubuntu with LTO+internalizing:
  ao1_d:             2.87 

Parameters used:
  WIDTH = HEIGHT = 256
  NSUBSAMPLES = 2
  NAO_SAMPLES = 8

--------------

CPU: Intel Core 2, 2 GHz (2 cores)

D code compiled with:
  DMD v1.041
  -O -release -inline

C code compiled with:
  gcc: V. 4.3.3-dw2-tdm-1 (GCC)
  LLVM: gcc version 4.2.1 (Based on Apple Inc. build 5636)
  For both:
  -Wall -O3 -s -fomit-frame-pointer -msse3 -march=core2

Python:
  ActivePython 2.6.1.1
  (r261:67515, Dec  5 2008, 13:58:38)
  [MSC v.1500 32 bit (Intel)] on win32

Psyco for Python 2.6, V.1.6.0 final 0

ShedSkin V. 0.1
  ss -i -w ao_ss.py
  using gcc version 4.3.3-dw2-tdm-1 (GCC)
  CCFLAGS=-O3 -s -fomit-frame-pointer -msse2 ...

Javac 1.6.0_12
Java SE runtime build 1.6.0_07-b06

def divide_and_conquer(value, isdivisible, conquer, divide, recombine):
    if isdivisible(value):
        return recombine(divide_and_conquer(sub_value, isdivisible, conquer, divide, recombine)
                         for sub_value in divide(value))
    else:
        return conquer(value)

identity = lambda x: x

def rotate2(square):
    def divide(square):
        half_len = len(square) // 2
        def sub_square(nrow, ncol):
            return [row[ncol: ncol + half_len] for row in square[nrow: nrow + half_len]]
        upper_left = sub_square(0, 0)
        lower_left = sub_square(half_len, 0)
        upper_right = sub_square(0, half_len)
        lower_right = sub_square(half_len, half_len)
        return [upper_left, lower_left, upper_right, lower_right]

    def recombine((upper_left, lower_left, upper_right, lower_right)):
        return [l + r for l,r in zip(upper_right, lower_right)] + \
               [l + r for l,r in zip(upper_left, lower_left)]

    return divide_and_conquer(square,
                              isdivisible=lambda value: len(value) > 1,
                              conquer=    identity,
                              divide=     divide,
                              recombine=  recombine)

BaseType!(TyIter) sum_squares3(TyIter)(TyIter value) {
    static if (IsIterable!(TyIter)) {
        BaseType1!(TyIter) x;
        return sum(select(sum_squares3(x), x, value));
    } else
        return value * value;
}

T[][] rotate1(T)(T[][] square) {
    if (len(square) > 1) {
        int half_len = len(square) / 2;
        T[][] sub_square(int nrow, int ncol) {
            T[] row;
            return select(row[ncol.. ncol + half_len], row, square[nrow.. nrow + half_len]);
        }
        auto upper_left = rotate1(sub_square(0, 0));
        auto lower_left = rotate1(sub_square(half_len, 0));
        auto upper_right = rotate1(sub_square(0, half_len));
        auto lower_right = rotate1(sub_square(half_len, half_len));
        T[][] lr;
        return select(lr[0] ~ lr[1], lr, azip(upper_right, lower_right)) ~
               select(lr[0] ~ lr[1], lr, azip(upper_left, lower_left));
    } else
        return square;
}

ReturnType!({ return F2.init(Init!(T)().init); }) divide_and_conquer(T, F1, F2, F3, F4)
                                                                    (T value, F1 isdivisible,
                                                                     F2 conquer, F3 divide,
                                                                     F4 recombine) {
    if (isdivisible(value)) {
        T[] aux;
        foreach (sub_value; divide(value))
            aux ~= divide_and_conquer(sub_value, isdivisible, conquer, divide, recombine);
        return recombine(aux);
    } else
        return conquer(value);
}

struct _identity { static T opCall(T)(T x) { return x; } }
_identity identity;

T[][] rotate2(T)(T[][] square) {
    T[][][] divide(T[][] square) {
        int half_len = len(square) / 2;
        T[][] sub_square(int nrow, int ncol) {
            T[] row;
            return select(row[ncol ..ncol + half_len], row, square[nrow .. nrow + half_len]);
        }
        auto upper_left = sub_square(0, 0);
        auto lower_left = sub_square(half_len, 0);
        auto upper_right = sub_square(0, half_len);
        auto lower_right = sub_square(half_len, half_len);
        return [upper_left, lower_left, upper_right, lower_right][];
    }

    T[][] recombine(T[][][] parts) {
        auto upper_left = parts[0];
        auto lower_left = parts[1];
        auto upper_right = parts[2];
        auto lower_right = parts[3];
        T[][] lr;
        return select(lr[0] ~ lr[1], lr, azip(upper_right, lower_right)) ~
               select(lr[0] ~ lr[1], lr, azip(upper_left, lower_left));
    }

    return divide_and_conquer(square,
                              (T[][] square){return len(square) > 1;},
                              identity,
                              ÷,
                              &recombine);
}

struct _sqr { static typeof(T.init * T.init) opCall(T)(T x) { return x * x; } }
_sqr sqr;

struct _sumb { static typeof(sum(Init!(T)().init)) opCall(T)(T seq) { return sum(seq); } }
_sumb sumb;

def isiterable(value):
    try:
        iter(value)
    except TypeError:
        return False
    else:
        return True

Timings smaller dataset, best of 3:
  C:                  0.15 s
  SS:                 0.29 s
  D to C:             0.33 s
  D:                  0.41 s
  SS:                 0.92 s  (with wrap around)
  Py 2.6 + Psyco:     4.84 s
  Py 2.6:            16.10 s

Timings larger dataset, best of 3:
  C:                 27.5 s
  SS:                43.4 s
  D to C:            76.9 s
  D:                 94   s
  SS:               199   s (with wrap around)
  Py 2.6 + Psyco:   untested
  Py 2.6:           untested

Timings larger dataset, best of 3:
  D to C:            26.09 s

Timings nx=ny=500, n_iter=1000, eps=1.0e-16, warm timings, best of 3:
  Python D:  459    s (163    X) estimated (code of Psyco 2)
  Python A:  289    s (102    X) estimated (code of SS 1)
  Python C:  210    s ( 74.7  X) estimated (code of Psyco 1)
  Python B:  208    s ( 74.0  X) estimated (code of SS 2)  
  Psyco 1:    41.5  s ( 14.8  X)
  Psyco 2:    37.47 s ( 13.3  X)
  D 1:         3.95 s (  1.40 X)
  D 2:         3.13 s (  1.11 X)
  ShedSkin 1:  2.92 s (  1.04 X)
  ShedSkin 2:  2.89 s (  1.03 X)
  C++:         2.81 s (  1    X)

	.p2align 4,,7
L38:
	fldl	-8(%edx,%eax,8)
	fldl	-8(%ebx,%eax,8)
	faddl	-8(%ecx,%eax,8)
	fmul	%st(4), %st
	fldl	-16(%edx,%eax,8)
	faddl	(%edx,%eax,8)
	fmul	%st(6), %st
	faddp	%st, %st(1)
	fmul	%st(3), %st
	fstl	-8(%edx,%eax,8)
	addl	$1, %eax
	fsubp	%st, %st(1)
	cmpl	%esi, %eax
	fmul	%st(0), %st
	faddp	%st, %st(1)
	jne	L38

LA9:		fld	qword ptr [ESI]
		fstp	qword ptr 038h[ESP]
		fld	qword ptr [EAX]
		fadd	qword ptr 0[EBP]
		fmul	qword ptr 028h[ESP]
		fld	qword ptr [EBX]
		fadd	qword ptr [EDI]
		fmul	qword ptr 020h[ESP]
		faddp	ST(1),ST
		fmul	qword ptr 030h[ESP]
		fstp	qword ptr [ESI]
		fld	qword ptr [ESI]
		fsub	qword ptr 038h[ESP]
		fstp	qword ptr 040h[ESP]
		fld	qword ptr 040h[ESP]
		fmul	ST,ST(0)
		fadd	qword ptr 048h[ESP]
		fstp	qword ptr 048h[ESP]
		add	ESI,8
		add	EBP,8
		add	EAX,8
		add	EDI,8
		add	EBX,8
		inc	EDX
		cmp	010h[ESP],EDX
		jg	LA9

               seconds  MB
  DMD class:   18.95    1.7
  GDC class:   17.91    1.8
  DMD struct:  11.77    1.7
  GDC struct:  12.31    1.8
  Python:      37.10    3.1  (ShedSkin version)
  Psyco:       15.68    3.5
  ShedSkin      6.35    1.6
  Java (1):     2.19    7.3
  Java (2):     2.10    7.8

import std.gc;
class ObjectTest { ObjectTest next; }
void main() {
    for (uint k = 0; k < 50; k++) {
        std.gc.disable();
        for (uint i = 0; i < 20; i++) {
            auto root = new ObjectTest();
            for (uint j = 0; j < 10_000; j++) {
                root.next = new ObjectTest();
                root = root.next;
            }
        }
        std.gc.fullCollect();
    }
}

-------------------

-------------------

SOURCES:

// obj_test_class.d
class ObjectTest { ObjectTest next; }
void main() {
    for (uint i = 0; i < 1_000; i++) {
        auto root = new ObjectTest();
        for (uint j = 0; j < 10_000; j++) {
            root.next = new ObjectTest();
            root = root.next;
        }
    }
}

-------------------

// obj_test_struct.d
struct ObjectTest { ObjectTest* next; }
void main() {
    for (uint i = 0; i < 1_000; i++) {
        auto root = new ObjectTest();
        for (uint j = 0; j < 10_000; j++) {
            root.next = new ObjectTest();
            root = root.next;
        }
    }
}

-------------------

// ObjectTest.java
public class ObjectTest {
    public ObjectTest next;
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            ObjectTest root = new ObjectTest();
            for (int j = 0; j < 10000; j++) {
                root.next = new ObjectTest();
                root = root.next;
            }
        }
    }
}

-------------------

# obj_test.py
from psyco.classes import __metaclass__
class ObjectTest: pass
def main():
    for i in xrange(1000): # N
        root = ObjectTest()
        for j in xrange(10000): # M
            root.next = ObjectTest()
            root = root.next
import psyco; psyco.full()
main()

-------------------

# obj_test_ss.py
class ObjectTest: pass
def main():
    for i in xrange(1000): # N
        root = ObjectTest()
        for j in xrange(10000): # M
            root.next = ObjectTest()
            root = root.next
main()