distance.py

import math
import time

radius = 6371

def distance(latA, lngA, latB, lngB):
    latAr = math.radians(latA)
    lngAr = math.radians(lngA)
    latBr = math.radians(latB)
    lngBr = math.radians(lngB)

    deltaLat = latBr - latAr
    deltaLng = lngBr - lngAr

    return radius * 2 * math.asin(math.sqrt(
            math.sin(deltaLat/2)**2 + math.cos(latAr)
            * math.cos(latBr) * (math.sin(deltaLng/2)**2)))

def bench():
    increment = 2.5

    start = time.time()
    latA = -90
    while(latA <= 90):
        lngA = -180
        while(lngA <= 180):
            latB = -90
            while(latB <= 90):
                lngB = -180    
                while(lngB <= 90):
                    distance(latA, lngA, latB, lngB)
                    lngB = lngB + increment
                latB = latB + increment            
            lngA = lngA + increment
        latA = latA + increment
    end = time.time()
    print end-start

if __name__ == '__main__':
    bench()

DistanceObjects.java

import java.util.Calendar;

public class DistanceObjects {
	private static final Float PI = new Float(Math.PI);
	private static final int RADIUS = 6371;
	
	public static Float degreeToRadian(Float degree) {
		return degree * (PI/180f);
	}
	
	public static Float distance(Float latA, Float lngA, Float latB, Float lngB) {
		final Float latAr = degreeToRadian(latA);
		final Float lngAr = degreeToRadian(lngA);
		final Float latBr = degreeToRadian(latB);
		final Float lngBr = degreeToRadian(lngB);
		
		final Float deltaLat = latBr - latAr;
		final Float deltaLng = lngBr - lngAr;
		
		return new Float(RADIUS * 2 * Math.asin(Math.sqrt(
					Math.pow(Math.sin(deltaLat/2), 2)
					+ Math.cos(latAr) * Math.cos(latBr) * 
					Math.pow(Math.sin(deltaLng/2), 2))));
	}
	
	public static void main(String[] args) {
		Float increment = 2.5f;
		long start = Calendar.getInstance().getTimeInMillis();
		for(Float latA = -90f; latA<= 90; latA=latA+increment) {
			for(Float lngA = -180f; lngA<= 180; lngA=lngA+increment) {
				for(Float latB = -90f; latB<= 90; latB=latB+increment) {
					for(Float lngB = -180f; lngB<= 180; lngB=lngB+increment) {
						distance(latA, lngA, latB, lngB);
					}
				}
			}
		}
		long end = Calendar.getInstance().getTimeInMillis();
		
		System.out.println("Runtime was: " + (end-start) + " Milliseconds");
	}
}

DistancePrimitives.java

import java.util.Calendar;

public class DistancePrimitives {
        //note: I'm using floats since that's what I did in Lisp.
        //The program runs in about the same time using doubles

	private static final float PI = (float)Math.PI;
	private static final int RADIUS = 6371;
	
	public static float degreeToRadian(float degree) {
		return degree * (PI/180f);
	}
	
	public static float distance(float latA, float lngA, float latB, float lngB) {
		final float latAr = degreeToRadian(latA);
		final float lngAr = degreeToRadian(lngA);
		final float latBr = degreeToRadian(latB);
		final float lngBr = degreeToRadian(lngB);
		
		final float deltaLat = latBr - latAr;
		final float deltaLng = lngBr - lngAr;
		
		return (float) (RADIUS * 2 * Math.asin(Math.sqrt(
					Math.pow(Math.sin(deltaLat/2), 2)
					+ Math.cos(latAr) * Math.cos(latBr) * 
					Math.pow(Math.sin(deltaLng/2), 2))));
	}
	
	public static void main(String[] args) {
		float increment = 2.5f;
		long start = Calendar.getInstance().getTimeInMillis();
		for(float latA = -90; latA<= 90; latA=latA+increment) {
			for(float lngA = -180; lngA<= 180; lngA=lngA+increment) {
				for(float latB = -90; latB<= 90; latB=latB+increment) {
					for(float lngB = -180; lngB<= 180; lngB=lngB+increment) {
						distance(latA, lngA, latB, lngB);
					}
				}
			}
		}
		long end = Calendar.getInstance().getTimeInMillis();
		
		System.out.println("Runtime was: " + (end-start) + " Milliseconds");
	}
}

optimized-distance.lisp

(declaim (optimize (speed 3) (safety 0) (debug 0)))

(defvar *earth-radius* (the fixnum 6371))

(defun degree-to-radian (deg)
  (declare (type single-float deg)
	   (optimize (speed 3) (safety 0) (debug 0)))
  (the single-float (* deg (/ (coerce pi 'single-float) 180))))

(defun distance (lata lnga latb lngb)
  (declare (type single-float lata lnga latb lngb)
	   (optimize (speed 3) (safety 0) (debug 0)))
  (let* ((lata-r (the single-float (degree-to-radian lata)))
	 (lnga-r (the single-float (degree-to-radian lnga)))
	 (latb-r (the single-float (degree-to-radian latb)))
	 (lngb-r (the single-float (degree-to-radian lngb)))
	 (delta-lat (the single-float (- latb-r lata-r)))
	 (delta-lng (the single-float (- lngb-r lnga-r))))
    (* (the fixnum (* (the fixnum *earth-radius*) 
		      2))
       (the single-float
	 (asin (the single-float
		 (sqrt (+  (expt (sin (/ delta-lat 2)) 2)
			   (* (cos lata-r)
			      (cos latb-r)
			      (expt (sin (/ delta-lng 2)) 2))))))))))

(defun test ()
  (let ((increment 2.5))
    (time  (loop for lata from -90.0 to 90.0 by increment do
		(loop for lnga from -180.0 to 180.0 by increment do
		     (loop for latb from -90.0 to 90.0 by increment do
			  (loop for lngb from -180.0 to 180.0 by increment do
			       (distance lata lnga latb lngb))))))))

unoptimized-distance.lisp

(defvar *earth-radius* 6371)

(defun degree-to-radian (deg)
  (* deg (/ pi 180)))

(defun distance (lata lnga latb lngb)
  (let* ((lata-r (degree-to-radian lata))
	 (lnga-r (degree-to-radian lnga))
	 (latb-r (degree-to-radian latb))
	 (lngb-r (degree-to-radian lngb))
	 (delta-lat (- latb-r lata-r))
	 (delta-lng (- lngb-r lnga-r)))
    (* *earth-radius*
       2 
       (asin (sqrt (+ (expt (sin (/ delta-lat 2)) 2)
		      (* (cos lata-r)
			 (cos latb-r)
			 (expt (sin (/ delta-lng 2)) 2))))))))

(defun test ()
  (let ((increment 2.5))
    (time  (loop for lata from -90 to 90 by increment do
		(loop for lnga from -180 to 180 by increment do
		     (loop for latb from -90 to 90 by increment do
			  (loop for lngb from -180 to 180 by increment do
			       (distance lata lnga latb lngb))))))))