Bearing on a great circle

Percentage Accurate: 78.8% → 99.7%

Time: 35.8s

Alternatives: 30

Speedup: 0.8×

Specification

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \left(\sin \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (sin (- lambda1 lambda2)) (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.sin((lambda1 - lambda2)) * Math.cos(phi2)), ((Math.cos(phi1) * Math.sin(phi2)) - ((Math.sin(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.sin((lambda1 - lambda2)) * math.cos(phi2)), ((math.cos(phi1) * math.sin(phi2)) - ((math.sin(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(sin(Float64(lambda1 - lambda2)) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(sin(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2)))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Initial Program: 78.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \left(\sin \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (sin (- lambda1 lambda2)) (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.sin((lambda1 - lambda2)) * Math.cos(phi2)), ((Math.cos(phi1) * Math.sin(phi2)) - ((Math.sin(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.sin((lambda1 - lambda2)) * math.cos(phi2)), ((math.cos(phi1) * math.sin(phi2)) - ((math.sin(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(sin(Float64(lambda1 - lambda2)) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(sin(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2)))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Alternative 1: 99.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\left(\cos \lambda_2 \cdot \cos \lambda_1\right) \cdot \sin \phi_1 + \mathsf{expm1}\left(\mathsf{log1p}\left(\sin \phi_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2\right)\right)\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
   (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (+
     (* (* (cos lambda2) (cos lambda1)) (sin phi1))
     (expm1 (log1p (* (sin phi1) (* (sin lambda1) (sin lambda2))))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (((cos(lambda2) * cos(lambda1)) * sin(phi1)) + expm1(log1p((sin(phi1) * (sin(lambda1) * sin(lambda2)))))))));
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(Float64(Float64(cos(lambda2) * cos(lambda1)) * sin(phi1)) + expm1(log1p(Float64(sin(phi1) * Float64(sin(lambda1) * sin(lambda2)))))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] + N[(Exp[N[Log[1 + N[(N[Sin[phi1], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 99.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\left(\cos \lambda_2 \cdot \cos \lambda_1\right) \cdot \sin \phi_1 + \sin \phi_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
   (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (+
     (* (* (cos lambda2) (cos lambda1)) (sin phi1))
     (* (sin phi1) (* (sin lambda1) (sin lambda2))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (((cos(lambda2) * cos(lambda1)) * sin(phi1)) + (sin(phi1) * (sin(lambda1) * sin(lambda2)))))));
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(Float64(Float64(cos(lambda2) * cos(lambda1)) * sin(phi1)) + Float64(sin(phi1) * Float64(sin(lambda1) * sin(lambda2)))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 99.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_2 \cdot \cos \lambda_1\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
   (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (*
     (sin phi1)
     (fma (sin lambda2) (sin lambda1) (* (cos lambda2) (cos lambda1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * fma(sin(lambda2), sin(lambda1), (cos(lambda2) * cos(lambda1)))))));
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda2) * cos(lambda1)))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 99.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\left(\cos \lambda_2 \cdot \cos \lambda_1\right) \cdot \sin \phi_1 + \sin \phi_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (cos phi2)
   (- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (+
     (* (* (cos lambda2) (cos lambda1)) (sin phi1))
     (* (sin phi1) (* (sin lambda1) (sin lambda2))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (((cos(lambda2) * cos(lambda1)) * sin(phi1)) + (sin(phi1) * (sin(lambda1) * sin(lambda2)))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (((cos(lambda2) * cos(lambda1)) * sin(phi1)) + (sin(phi1) * (sin(lambda1) * sin(lambda2)))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (((Math.cos(lambda2) * Math.cos(lambda1)) * Math.sin(phi1)) + (Math.sin(phi1) * (Math.sin(lambda1) * Math.sin(lambda2)))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (((math.cos(lambda2) * math.cos(lambda1)) * math.sin(phi1)) + (math.sin(phi1) * (math.sin(lambda1) * math.sin(lambda2)))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(Float64(Float64(cos(lambda2) * cos(lambda1)) * sin(phi1)) + Float64(sin(phi1) * Float64(sin(lambda1) * sin(lambda2)))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (((cos(lambda2) * cos(lambda1)) * sin(phi1)) + (sin(phi1) * (sin(lambda1) * sin(lambda2)))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 99.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \lambda_1 + \sin \lambda_1 \cdot \sin \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
   (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (*
     (sin phi1)
     (+ (* (cos lambda2) (cos lambda1)) (* (sin lambda1) (sin lambda2))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2)))))));
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * Float64(Float64(cos(lambda2) * cos(lambda1)) + Float64(sin(lambda1) * sin(lambda2)))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 99.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \lambda_1 + \sin \lambda_1 \cdot \sin \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (cos phi2)
   (- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
  (-
   (* (cos phi1) (sin phi2))
   (*
    (cos phi2)
    (*
     (sin phi1)
     (+ (* (cos lambda2) (cos lambda1)) (* (sin lambda1) (sin lambda2))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2)))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2)))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * ((Math.cos(lambda2) * Math.cos(lambda1)) + (Math.sin(lambda1) * Math.sin(lambda2)))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * ((math.cos(lambda2) * math.cos(lambda1)) + (math.sin(lambda1) * math.sin(lambda2)))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * Float64(Float64(cos(lambda2) * cos(lambda1)) + Float64(sin(lambda1) * sin(lambda2)))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2)))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 89.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \mathsf{log1p}\left(\mathsf{expm1}\left(\cos \lambda_1 \cdot \sin \lambda_2\right)\right)\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (cos phi2)
   (-
    (* (sin lambda1) (cos lambda2))
    (log1p (expm1 (* (cos lambda1) (sin lambda2))))))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - log1p(expm1((cos(lambda1) * sin(lambda2)))))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
}

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - Math.log1p(Math.expm1((Math.cos(lambda1) * Math.sin(lambda2)))))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - math.log1p(math.expm1((math.cos(lambda1) * math.sin(lambda2)))))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - log1p(expm1(Float64(cos(lambda1) * sin(lambda2)))))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[Log[1 + N[(Exp[N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 89.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
   (cos phi2))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 89.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\lambda_1 \leq -7.2 \cdot 10^{-5} \lor \neg \left(\lambda_1 \leq 2.8 \cdot 10^{-8}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \sin \phi_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\lambda_1 \cdot \cos \lambda_2 - \sin \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \left(\cos \lambda_2 + \lambda_1 \cdot \sin \lambda_2\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))))
   (if (or (<= lambda1 -7.2e-5) (not (<= lambda1 2.8e-8)))
     (atan2
      (*
       (cos phi2)
       (- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
      (- t_0 (* (cos phi2) (* (cos lambda1) (sin phi1)))))
     (atan2
      (* (cos phi2) (- (* lambda1 (cos lambda2)) (sin lambda2)))
      (-
       t_0
       (*
        (cos phi2)
        (* (sin phi1) (+ (cos lambda2) (* lambda1 (sin lambda2))))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double tmp;
	if ((lambda1 <= -7.2e-5) || !(lambda1 <= 2.8e-8)) {
		tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	} else {
		tmp = atan2((cos(phi2) * ((lambda1 * cos(lambda2)) - sin(lambda2))), (t_0 - (cos(phi2) * (sin(phi1) * (cos(lambda2) + (lambda1 * sin(lambda2)))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    if ((lambda1 <= (-7.2d-5)) .or. (.not. (lambda1 <= 2.8d-8))) then
        tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))))
    else
        tmp = atan2((cos(phi2) * ((lambda1 * cos(lambda2)) - sin(lambda2))), (t_0 - (cos(phi2) * (sin(phi1) * (cos(lambda2) + (lambda1 * sin(lambda2)))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if ((lambda1 <= -7.2e-5) || !(lambda1 <= 2.8e-8)) {
		tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * Math.sin(phi1)))));
	} else {
		tmp = Math.atan2((Math.cos(phi2) * ((lambda1 * Math.cos(lambda2)) - Math.sin(lambda2))), (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * (Math.cos(lambda2) + (lambda1 * Math.sin(lambda2)))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if (lambda1 <= -7.2e-5) or not (lambda1 <= 2.8e-8):
		tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), (t_0 - (math.cos(phi2) * (math.cos(lambda1) * math.sin(phi1)))))
	else:
		tmp = math.atan2((math.cos(phi2) * ((lambda1 * math.cos(lambda2)) - math.sin(lambda2))), (t_0 - (math.cos(phi2) * (math.sin(phi1) * (math.cos(lambda2) + (lambda1 * math.sin(lambda2)))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((lambda1 <= -7.2e-5) || !(lambda1 <= 2.8e-8))
		tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * sin(phi1)))));
	else
		tmp = atan(Float64(cos(phi2) * Float64(Float64(lambda1 * cos(lambda2)) - sin(lambda2))), Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * Float64(cos(lambda2) + Float64(lambda1 * sin(lambda2)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if ((lambda1 <= -7.2e-5) || ~((lambda1 <= 2.8e-8)))
		tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	else
		tmp = atan2((cos(phi2) * ((lambda1 * cos(lambda2)) - sin(lambda2))), (t_0 - (cos(phi2) * (sin(phi1) * (cos(lambda2) + (lambda1 * sin(lambda2)))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[lambda1, -7.2e-5], N[Not[LessEqual[lambda1, 2.8e-8]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(lambda1 * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] + N[(lambda1 * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 87.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_1 \leq -1 \cdot 10^{-16} \lor \neg \left(\phi_1 \leq 1.15 \cdot 10^{-39}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \sin \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \left(-\cos \lambda_1\right) \cdot \sin \lambda_2\right) \cdot \cos \phi_2}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))))
   (if (or (<= phi1 -1e-16) (not (<= phi1 1.15e-39)))
     (atan2
      (* (cos phi2) (- (* (sin lambda1) (cos lambda2)) (sin lambda2)))
      (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
     (atan2
      (*
       (fma (sin lambda1) (cos lambda2) (* (- (cos lambda1)) (sin lambda2)))
       (cos phi2))
      (- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double tmp;
	if ((phi1 <= -1e-16) || !(phi1 <= 1.15e-39)) {
		tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - sin(lambda2))), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2((fma(sin(lambda1), cos(lambda2), (-cos(lambda1) * sin(lambda2))) * cos(phi2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
	}
	return tmp;
}

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((phi1 <= -1e-16) || !(phi1 <= 1.15e-39))
		tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - sin(lambda2))), Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(Float64(-cos(lambda1)) * sin(lambda2))) * cos(phi2)), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1)))));
	end
	return tmp
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi1, -1e-16], N[Not[LessEqual[phi1, 1.15e-39]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[((-N[Cos[lambda1], $MachinePrecision]) * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 89.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (*
   (cos phi2)
   (- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 87.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \lambda_1 \cdot \cos \lambda_2\\ t_1 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_1 \leq -1.8 \cdot 10^{-5} \lor \neg \left(\phi_1 \leq 1.15 \cdot 10^{-39}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(t_0 - \sin \lambda_2\right)}{t_1 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(t_0 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_1 - \cos \phi_2 \cdot \left(\phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (sin lambda1) (cos lambda2))) (t_1 (* (cos phi1) (sin phi2))))
   (if (or (<= phi1 -1.8e-5) (not (<= phi1 1.15e-39)))
     (atan2
      (* (cos phi2) (- t_0 (sin lambda2)))
      (- t_1 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
     (atan2
      (* (cos phi2) (- t_0 (* (cos lambda1) (sin lambda2))))
      (- t_1 (* (cos phi2) (* phi1 (cos (- lambda2 lambda1)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = sin(lambda1) * cos(lambda2);
	double t_1 = cos(phi1) * sin(phi2);
	double tmp;
	if ((phi1 <= -1.8e-5) || !(phi1 <= 1.15e-39)) {
		tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = sin(lambda1) * cos(lambda2)
    t_1 = cos(phi1) * sin(phi2)
    if ((phi1 <= (-1.8d-5)) .or. (.not. (phi1 <= 1.15d-39))) then
        tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    else
        tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.sin(lambda1) * Math.cos(lambda2);
	double t_1 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if ((phi1 <= -1.8e-5) || !(phi1 <= 1.15e-39)) {
		tmp = Math.atan2((Math.cos(phi2) * (t_0 - Math.sin(lambda2))), (t_1 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	} else {
		tmp = Math.atan2((Math.cos(phi2) * (t_0 - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_1 - (Math.cos(phi2) * (phi1 * Math.cos((lambda2 - lambda1))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.sin(lambda1) * math.cos(lambda2)
	t_1 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if (phi1 <= -1.8e-5) or not (phi1 <= 1.15e-39):
		tmp = math.atan2((math.cos(phi2) * (t_0 - math.sin(lambda2))), (t_1 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	else:
		tmp = math.atan2((math.cos(phi2) * (t_0 - (math.cos(lambda1) * math.sin(lambda2)))), (t_1 - (math.cos(phi2) * (phi1 * math.cos((lambda2 - lambda1))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(sin(lambda1) * cos(lambda2))
	t_1 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((phi1 <= -1.8e-5) || !(phi1 <= 1.15e-39))
		tmp = atan(Float64(cos(phi2) * Float64(t_0 - sin(lambda2))), Float64(t_1 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(Float64(cos(phi2) * Float64(t_0 - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_1 - Float64(cos(phi2) * Float64(phi1 * cos(Float64(lambda2 - lambda1))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = sin(lambda1) * cos(lambda2);
	t_1 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if ((phi1 <= -1.8e-5) || ~((phi1 <= 1.15e-39)))
		tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	else
		tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi1, -1.8e-5], N[Not[LessEqual[phi1, 1.15e-39]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(t$95$0 - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(t$95$0 - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Cos[phi2], $MachinePrecision] * N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 87.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \lambda_1 \cdot \cos \lambda_2\\ t_1 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_1 \leq -8 \cdot 10^{-16} \lor \neg \left(\phi_1 \leq 1.15 \cdot 10^{-39}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(t_0 - \sin \lambda_2\right)}{t_1 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(t_0 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_1 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (sin lambda1) (cos lambda2))) (t_1 (* (cos phi1) (sin phi2))))
   (if (or (<= phi1 -8e-16) (not (<= phi1 1.15e-39)))
     (atan2
      (* (cos phi2) (- t_0 (sin lambda2)))
      (- t_1 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
     (atan2
      (* (cos phi2) (- t_0 (* (cos lambda1) (sin lambda2))))
      (- t_1 (* (sin phi1) (cos (- lambda2 lambda1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = sin(lambda1) * cos(lambda2);
	double t_1 = cos(phi1) * sin(phi2);
	double tmp;
	if ((phi1 <= -8e-16) || !(phi1 <= 1.15e-39)) {
		tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (sin(phi1) * cos((lambda2 - lambda1)))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = sin(lambda1) * cos(lambda2)
    t_1 = cos(phi1) * sin(phi2)
    if ((phi1 <= (-8d-16)) .or. (.not. (phi1 <= 1.15d-39))) then
        tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    else
        tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (sin(phi1) * cos((lambda2 - lambda1)))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.sin(lambda1) * Math.cos(lambda2);
	double t_1 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if ((phi1 <= -8e-16) || !(phi1 <= 1.15e-39)) {
		tmp = Math.atan2((Math.cos(phi2) * (t_0 - Math.sin(lambda2))), (t_1 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	} else {
		tmp = Math.atan2((Math.cos(phi2) * (t_0 - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_1 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.sin(lambda1) * math.cos(lambda2)
	t_1 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if (phi1 <= -8e-16) or not (phi1 <= 1.15e-39):
		tmp = math.atan2((math.cos(phi2) * (t_0 - math.sin(lambda2))), (t_1 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	else:
		tmp = math.atan2((math.cos(phi2) * (t_0 - (math.cos(lambda1) * math.sin(lambda2)))), (t_1 - (math.sin(phi1) * math.cos((lambda2 - lambda1)))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(sin(lambda1) * cos(lambda2))
	t_1 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((phi1 <= -8e-16) || !(phi1 <= 1.15e-39))
		tmp = atan(Float64(cos(phi2) * Float64(t_0 - sin(lambda2))), Float64(t_1 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(Float64(cos(phi2) * Float64(t_0 - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_1 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = sin(lambda1) * cos(lambda2);
	t_1 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if ((phi1 <= -8e-16) || ~((phi1 <= 1.15e-39)))
		tmp = atan2((cos(phi2) * (t_0 - sin(lambda2))), (t_1 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	else
		tmp = atan2((cos(phi2) * (t_0 - (cos(lambda1) * sin(lambda2)))), (t_1 - (sin(phi1) * cos((lambda2 - lambda1)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi1, -8e-16], N[Not[LessEqual[phi1, 1.15e-39]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(t$95$0 - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(t$95$0 - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 80.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \sin \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (cos phi2) (- (* (sin lambda1) (cos lambda2)) (sin lambda2)))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - sin(lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - sin(lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - Math.sin(lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - math.sin(lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - sin(lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - sin(lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 78.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\cos \left(\lambda_1 - \lambda_2\right)\right)\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (cos phi2) (sin (- lambda1 lambda2)))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (log1p (expm1 (cos (- lambda1 lambda2)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * log1p(expm1(cos((lambda1 - lambda2))))))));
}

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * Math.log1p(Math.expm1(Math.cos((lambda1 - lambda2))))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * math.log1p(math.expm1(math.cos((lambda1 - lambda2))))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * log1p(expm1(cos(Float64(lambda1 - lambda2))))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Log[1 + N[(Exp[N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 62.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \cos \left(\lambda_2 - \lambda_1\right)\\ t_2 := \sin \left(\lambda_1 - \lambda_2\right)\\ \mathbf{if}\;\phi_2 \leq -1.16 \cdot 10^{+169}:\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_2}{t_0 - \cos \phi_2 \cdot \left(\phi_1 \cdot t_1\right)}\\ \mathbf{elif}\;\phi_2 \leq -0.156 \lor \neg \left(\phi_2 \leq 9.2 \cdot 10^{-9}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_2 \cdot \left(1 + -0.5 \cdot {\phi_2}^{2}\right)}{t_0 - \sin \phi_1 \cdot t_1}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2)))
        (t_1 (cos (- lambda2 lambda1)))
        (t_2 (sin (- lambda1 lambda2))))
   (if (<= phi2 -1.16e+169)
     (atan2 (* (cos phi2) t_2) (- t_0 (* (cos phi2) (* phi1 t_1))))
     (if (or (<= phi2 -0.156) (not (<= phi2 9.2e-9)))
       (atan2
        (* (sin lambda1) (cos phi2))
        (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
       (atan2
        (* t_2 (+ 1.0 (* -0.5 (pow phi2 2.0))))
        (- t_0 (* (sin phi1) t_1)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = cos((lambda2 - lambda1));
	double t_2 = sin((lambda1 - lambda2));
	double tmp;
	if (phi2 <= -1.16e+169) {
		tmp = atan2((cos(phi2) * t_2), (t_0 - (cos(phi2) * (phi1 * t_1))));
	} else if ((phi2 <= -0.156) || !(phi2 <= 9.2e-9)) {
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2((t_2 * (1.0 + (-0.5 * pow(phi2, 2.0)))), (t_0 - (sin(phi1) * t_1)));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = cos((lambda2 - lambda1))
    t_2 = sin((lambda1 - lambda2))
    if (phi2 <= (-1.16d+169)) then
        tmp = atan2((cos(phi2) * t_2), (t_0 - (cos(phi2) * (phi1 * t_1))))
    else if ((phi2 <= (-0.156d0)) .or. (.not. (phi2 <= 9.2d-9))) then
        tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    else
        tmp = atan2((t_2 * (1.0d0 + ((-0.5d0) * (phi2 ** 2.0d0)))), (t_0 - (sin(phi1) * t_1)))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.cos((lambda2 - lambda1));
	double t_2 = Math.sin((lambda1 - lambda2));
	double tmp;
	if (phi2 <= -1.16e+169) {
		tmp = Math.atan2((Math.cos(phi2) * t_2), (t_0 - (Math.cos(phi2) * (phi1 * t_1))));
	} else if ((phi2 <= -0.156) || !(phi2 <= 9.2e-9)) {
		tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	} else {
		tmp = Math.atan2((t_2 * (1.0 + (-0.5 * Math.pow(phi2, 2.0)))), (t_0 - (Math.sin(phi1) * t_1)));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.cos((lambda2 - lambda1))
	t_2 = math.sin((lambda1 - lambda2))
	tmp = 0
	if phi2 <= -1.16e+169:
		tmp = math.atan2((math.cos(phi2) * t_2), (t_0 - (math.cos(phi2) * (phi1 * t_1))))
	elif (phi2 <= -0.156) or not (phi2 <= 9.2e-9):
		tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	else:
		tmp = math.atan2((t_2 * (1.0 + (-0.5 * math.pow(phi2, 2.0)))), (t_0 - (math.sin(phi1) * t_1)))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = cos(Float64(lambda2 - lambda1))
	t_2 = sin(Float64(lambda1 - lambda2))
	tmp = 0.0
	if (phi2 <= -1.16e+169)
		tmp = atan(Float64(cos(phi2) * t_2), Float64(t_0 - Float64(cos(phi2) * Float64(phi1 * t_1))));
	elseif ((phi2 <= -0.156) || !(phi2 <= 9.2e-9))
		tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(Float64(t_2 * Float64(1.0 + Float64(-0.5 * (phi2 ^ 2.0)))), Float64(t_0 - Float64(sin(phi1) * t_1)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = cos((lambda2 - lambda1));
	t_2 = sin((lambda1 - lambda2));
	tmp = 0.0;
	if (phi2 <= -1.16e+169)
		tmp = atan2((cos(phi2) * t_2), (t_0 - (cos(phi2) * (phi1 * t_1))));
	elseif ((phi2 <= -0.156) || ~((phi2 <= 9.2e-9)))
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	else
		tmp = atan2((t_2 * (1.0 + (-0.5 * (phi2 ^ 2.0)))), (t_0 - (sin(phi1) * t_1)));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, -1.16e+169], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$2), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(phi1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[Or[LessEqual[phi2, -0.156], N[Not[LessEqual[phi2, 9.2e-9]], $MachinePrecision]], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(t$95$2 * N[(1.0 + N[(-0.5 * N[Power[phi2, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 78.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\ \mathbf{if}\;\lambda_2 \leq -90:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_2 \cdot \sin \phi_1\right)}\\ \mathbf{elif}\;\lambda_2 \leq 0.0056:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \sin \phi_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2)))
        (t_1 (* (cos phi2) (sin (- lambda1 lambda2)))))
   (if (<= lambda2 -90.0)
     (atan2 t_1 (- t_0 (* (cos phi2) (* (cos lambda2) (sin phi1)))))
     (if (<= lambda2 0.0056)
       (atan2 t_1 (- t_0 (* (cos phi2) (* (cos lambda1) (sin phi1)))))
       (atan2
        (* (cos phi2) (sin (- lambda2)))
        (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = cos(phi2) * sin((lambda1 - lambda2));
	double tmp;
	if (lambda2 <= -90.0) {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	} else if (lambda2 <= 0.0056) {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	} else {
		tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = cos(phi2) * sin((lambda1 - lambda2))
    if (lambda2 <= (-90.0d0)) then
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))))
    else if (lambda2 <= 0.0056d0) then
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))))
    else
        tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
	double tmp;
	if (lambda2 <= -90.0) {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.cos(lambda2) * Math.sin(phi1)))));
	} else if (lambda2 <= 0.0056) {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * Math.sin(phi1)))));
	} else {
		tmp = Math.atan2((Math.cos(phi2) * Math.sin(-lambda2)), (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.cos(phi2) * math.sin((lambda1 - lambda2))
	tmp = 0
	if lambda2 <= -90.0:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.cos(lambda2) * math.sin(phi1)))))
	elif lambda2 <= 0.0056:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.cos(lambda1) * math.sin(phi1)))))
	else:
		tmp = math.atan2((math.cos(phi2) * math.sin(-lambda2)), (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2)))
	tmp = 0.0
	if (lambda2 <= -90.0)
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda2) * sin(phi1)))));
	elseif (lambda2 <= 0.0056)
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * sin(phi1)))));
	else
		tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = cos(phi2) * sin((lambda1 - lambda2));
	tmp = 0.0;
	if (lambda2 <= -90.0)
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	elseif (lambda2 <= 0.0056)
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	else
		tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -90.0], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda2, 0.0056], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 73.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\ \mathbf{if}\;\phi_2 \leq -4 \cdot 10^{-5} \lor \neg \left(\phi_2 \leq 1.15 \cdot 10^{-52}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \sin \phi_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (sin (- lambda1 lambda2))))
   (if (or (<= phi2 -4e-5) (not (<= phi2 1.15e-52)))
     (atan2
      (* (cos phi2) t_1)
      (- t_0 (* (cos phi2) (* (cos lambda1) (sin phi1)))))
     (atan2
      t_1
      (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = sin((lambda1 - lambda2));
	double tmp;
	if ((phi2 <= -4e-5) || !(phi2 <= 1.15e-52)) {
		tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	} else {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = sin((lambda1 - lambda2))
    if ((phi2 <= (-4d-5)) .or. (.not. (phi2 <= 1.15d-52))) then
        tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))))
    else
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.sin((lambda1 - lambda2));
	double tmp;
	if ((phi2 <= -4e-5) || !(phi2 <= 1.15e-52)) {
		tmp = Math.atan2((Math.cos(phi2) * t_1), (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * Math.sin(phi1)))));
	} else {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.sin((lambda1 - lambda2))
	tmp = 0
	if (phi2 <= -4e-5) or not (phi2 <= 1.15e-52):
		tmp = math.atan2((math.cos(phi2) * t_1), (t_0 - (math.cos(phi2) * (math.cos(lambda1) * math.sin(phi1)))))
	else:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = sin(Float64(lambda1 - lambda2))
	tmp = 0.0
	if ((phi2 <= -4e-5) || !(phi2 <= 1.15e-52))
		tmp = atan(Float64(cos(phi2) * t_1), Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * sin(phi1)))));
	else
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = sin((lambda1 - lambda2));
	tmp = 0.0;
	if ((phi2 <= -4e-5) || ~((phi2 <= 1.15e-52)))
		tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	else
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi2, -4e-5], N[Not[LessEqual[phi2, 1.15e-52]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 19: 78.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\ \mathbf{if}\;\lambda_2 \leq -90 \lor \neg \left(\lambda_2 \leq 9 \cdot 10^{-18}\right):\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_2 \cdot \sin \phi_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \sin \phi_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2)))
        (t_1 (* (cos phi2) (sin (- lambda1 lambda2)))))
   (if (or (<= lambda2 -90.0) (not (<= lambda2 9e-18)))
     (atan2 t_1 (- t_0 (* (cos phi2) (* (cos lambda2) (sin phi1)))))
     (atan2 t_1 (- t_0 (* (cos phi2) (* (cos lambda1) (sin phi1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = cos(phi2) * sin((lambda1 - lambda2));
	double tmp;
	if ((lambda2 <= -90.0) || !(lambda2 <= 9e-18)) {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	} else {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = cos(phi2) * sin((lambda1 - lambda2))
    if ((lambda2 <= (-90.0d0)) .or. (.not. (lambda2 <= 9d-18))) then
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))))
    else
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
	double tmp;
	if ((lambda2 <= -90.0) || !(lambda2 <= 9e-18)) {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.cos(lambda2) * Math.sin(phi1)))));
	} else {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * Math.sin(phi1)))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.cos(phi2) * math.sin((lambda1 - lambda2))
	tmp = 0
	if (lambda2 <= -90.0) or not (lambda2 <= 9e-18):
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.cos(lambda2) * math.sin(phi1)))))
	else:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.cos(lambda1) * math.sin(phi1)))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2)))
	tmp = 0.0
	if ((lambda2 <= -90.0) || !(lambda2 <= 9e-18))
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda2) * sin(phi1)))));
	else
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * sin(phi1)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = cos(phi2) * sin((lambda1 - lambda2));
	tmp = 0.0;
	if ((lambda2 <= -90.0) || ~((lambda2 <= 9e-18)))
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	else
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[lambda2, -90.0], N[Not[LessEqual[lambda2, 9e-18]], $MachinePrecision]], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 20: 78.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (cos phi2) (sin (- lambda1 lambda2)))
  (-
   (* (cos phi1) (sin phi2))
   (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 21: 53.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_2 \leq -0.53 \lor \neg \left(\phi_2 \leq 6.5 \cdot 10^{+20}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_0 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))))
   (if (or (<= phi2 -0.53) (not (<= phi2 6.5e+20)))
     (atan2
      (* (sin lambda1) (cos phi2))
      (- t_0 (* phi1 (cos (- lambda2 lambda1)))))
     (atan2
      (sin (- lambda1 lambda2))
      (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double tmp;
	if ((phi2 <= -0.53) || !(phi2 <= 6.5e+20)) {
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
	} else {
		tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    if ((phi2 <= (-0.53d0)) .or. (.not. (phi2 <= 6.5d+20))) then
        tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))))
    else
        tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if ((phi2 <= -0.53) || !(phi2 <= 6.5e+20)) {
		tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), (t_0 - (phi1 * Math.cos((lambda2 - lambda1)))));
	} else {
		tmp = Math.atan2(Math.sin((lambda1 - lambda2)), (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if (phi2 <= -0.53) or not (phi2 <= 6.5e+20):
		tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), (t_0 - (phi1 * math.cos((lambda2 - lambda1)))))
	else:
		tmp = math.atan2(math.sin((lambda1 - lambda2)), (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((phi2 <= -0.53) || !(phi2 <= 6.5e+20))
		tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_0 - Float64(phi1 * cos(Float64(lambda2 - lambda1)))));
	else
		tmp = atan(sin(Float64(lambda1 - lambda2)), Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if ((phi2 <= -0.53) || ~((phi2 <= 6.5e+20)))
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
	else
		tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi2, -0.53], N[Not[LessEqual[phi2, 6.5e+20]], $MachinePrecision]], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 22: 62.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\ \mathbf{if}\;\phi_2 \leq -0.035 \lor \neg \left(\phi_2 \leq 16200000000000\right):\\ \;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_1}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \phi_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (sin (- lambda1 lambda2))))
   (if (or (<= phi2 -0.035) (not (<= phi2 16200000000000.0)))
     (atan2 (* (cos phi2) t_1) (- t_0 (* (cos phi2) (* (cos lambda1) phi1))))
     (atan2
      t_1
      (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = sin((lambda1 - lambda2));
	double tmp;
	if ((phi2 <= -0.035) || !(phi2 <= 16200000000000.0)) {
		tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * phi1))));
	} else {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = sin((lambda1 - lambda2))
    if ((phi2 <= (-0.035d0)) .or. (.not. (phi2 <= 16200000000000.0d0))) then
        tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * phi1))))
    else
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.sin((lambda1 - lambda2));
	double tmp;
	if ((phi2 <= -0.035) || !(phi2 <= 16200000000000.0)) {
		tmp = Math.atan2((Math.cos(phi2) * t_1), (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * phi1))));
	} else {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.sin((lambda1 - lambda2))
	tmp = 0
	if (phi2 <= -0.035) or not (phi2 <= 16200000000000.0):
		tmp = math.atan2((math.cos(phi2) * t_1), (t_0 - (math.cos(phi2) * (math.cos(lambda1) * phi1))))
	else:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = sin(Float64(lambda1 - lambda2))
	tmp = 0.0
	if ((phi2 <= -0.035) || !(phi2 <= 16200000000000.0))
		tmp = atan(Float64(cos(phi2) * t_1), Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * phi1))));
	else
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = sin((lambda1 - lambda2));
	tmp = 0.0;
	if ((phi2 <= -0.035) || ~((phi2 <= 16200000000000.0)))
		tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(phi2) * (cos(lambda1) * phi1))));
	else
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi2, -0.035], N[Not[LessEqual[phi2, 16200000000000.0]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 23: 62.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\ t_2 := \cos \phi_2 \cdot t_1\\ \mathbf{if}\;\phi_2 \leq -0.0011:\\ \;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \phi_1\right)}\\ \mathbf{elif}\;\phi_2 \leq 920000000000:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_2 \cdot \phi_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2)))
        (t_1 (sin (- lambda1 lambda2)))
        (t_2 (* (cos phi2) t_1)))
   (if (<= phi2 -0.0011)
     (atan2 t_2 (- t_0 (* (cos phi2) (* (cos lambda1) phi1))))
     (if (<= phi2 920000000000.0)
       (atan2
        t_1
        (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
       (atan2 t_2 (- t_0 (* (cos phi2) (* (cos lambda2) phi1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = sin((lambda1 - lambda2));
	double t_2 = cos(phi2) * t_1;
	double tmp;
	if (phi2 <= -0.0011) {
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda1) * phi1))));
	} else if (phi2 <= 920000000000.0) {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = sin((lambda1 - lambda2))
    t_2 = cos(phi2) * t_1
    if (phi2 <= (-0.0011d0)) then
        tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda1) * phi1))))
    else if (phi2 <= 920000000000.0d0) then
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    else
        tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.sin((lambda1 - lambda2));
	double t_2 = Math.cos(phi2) * t_1;
	double tmp;
	if (phi2 <= -0.0011) {
		tmp = Math.atan2(t_2, (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * phi1))));
	} else if (phi2 <= 920000000000.0) {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	} else {
		tmp = Math.atan2(t_2, (t_0 - (Math.cos(phi2) * (Math.cos(lambda2) * phi1))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.sin((lambda1 - lambda2))
	t_2 = math.cos(phi2) * t_1
	tmp = 0
	if phi2 <= -0.0011:
		tmp = math.atan2(t_2, (t_0 - (math.cos(phi2) * (math.cos(lambda1) * phi1))))
	elif phi2 <= 920000000000.0:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	else:
		tmp = math.atan2(t_2, (t_0 - (math.cos(phi2) * (math.cos(lambda2) * phi1))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = sin(Float64(lambda1 - lambda2))
	t_2 = Float64(cos(phi2) * t_1)
	tmp = 0.0
	if (phi2 <= -0.0011)
		tmp = atan(t_2, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * phi1))));
	elseif (phi2 <= 920000000000.0)
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(t_2, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda2) * phi1))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = sin((lambda1 - lambda2));
	t_2 = cos(phi2) * t_1;
	tmp = 0.0;
	if (phi2 <= -0.0011)
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda1) * phi1))));
	elseif (phi2 <= 920000000000.0)
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	else
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]}, If[LessEqual[phi2, -0.0011], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi2, 920000000000.0], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 24: 62.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\ t_2 := \cos \phi_2 \cdot t_1\\ \mathbf{if}\;\phi_2 \leq -0.00115:\\ \;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \cos \phi_2 \cdot \left(\phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)}\\ \mathbf{elif}\;\phi_2 \leq 52000000000:\\ \;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \cos \phi_2 \cdot \left(\sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_2 \cdot \phi_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2)))
        (t_1 (sin (- lambda1 lambda2)))
        (t_2 (* (cos phi2) t_1)))
   (if (<= phi2 -0.00115)
     (atan2 t_2 (- t_0 (* (cos phi2) (* phi1 (cos (- lambda2 lambda1))))))
     (if (<= phi2 52000000000.0)
       (atan2
        t_1
        (- t_0 (* (cos phi2) (* (sin phi1) (cos (- lambda1 lambda2))))))
       (atan2 t_2 (- t_0 (* (cos phi2) (* (cos lambda2) phi1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double t_1 = sin((lambda1 - lambda2));
	double t_2 = cos(phi2) * t_1;
	double tmp;
	if (phi2 <= -0.00115) {
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
	} else if (phi2 <= 52000000000.0) {
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	} else {
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    t_1 = sin((lambda1 - lambda2))
    t_2 = cos(phi2) * t_1
    if (phi2 <= (-0.00115d0)) then
        tmp = atan2(t_2, (t_0 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))))
    else if (phi2 <= 52000000000.0d0) then
        tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))))
    else
        tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double t_1 = Math.sin((lambda1 - lambda2));
	double t_2 = Math.cos(phi2) * t_1;
	double tmp;
	if (phi2 <= -0.00115) {
		tmp = Math.atan2(t_2, (t_0 - (Math.cos(phi2) * (phi1 * Math.cos((lambda2 - lambda1))))));
	} else if (phi2 <= 52000000000.0) {
		tmp = Math.atan2(t_1, (t_0 - (Math.cos(phi2) * (Math.sin(phi1) * Math.cos((lambda1 - lambda2))))));
	} else {
		tmp = Math.atan2(t_2, (t_0 - (Math.cos(phi2) * (Math.cos(lambda2) * phi1))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	t_1 = math.sin((lambda1 - lambda2))
	t_2 = math.cos(phi2) * t_1
	tmp = 0
	if phi2 <= -0.00115:
		tmp = math.atan2(t_2, (t_0 - (math.cos(phi2) * (phi1 * math.cos((lambda2 - lambda1))))))
	elif phi2 <= 52000000000.0:
		tmp = math.atan2(t_1, (t_0 - (math.cos(phi2) * (math.sin(phi1) * math.cos((lambda1 - lambda2))))))
	else:
		tmp = math.atan2(t_2, (t_0 - (math.cos(phi2) * (math.cos(lambda2) * phi1))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	t_1 = sin(Float64(lambda1 - lambda2))
	t_2 = Float64(cos(phi2) * t_1)
	tmp = 0.0
	if (phi2 <= -0.00115)
		tmp = atan(t_2, Float64(t_0 - Float64(cos(phi2) * Float64(phi1 * cos(Float64(lambda2 - lambda1))))));
	elseif (phi2 <= 52000000000.0)
		tmp = atan(t_1, Float64(t_0 - Float64(cos(phi2) * Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))));
	else
		tmp = atan(t_2, Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda2) * phi1))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	t_1 = sin((lambda1 - lambda2));
	t_2 = cos(phi2) * t_1;
	tmp = 0.0;
	if (phi2 <= -0.00115)
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
	elseif (phi2 <= 52000000000.0)
		tmp = atan2(t_1, (t_0 - (cos(phi2) * (sin(phi1) * cos((lambda1 - lambda2))))));
	else
		tmp = atan2(t_2, (t_0 - (cos(phi2) * (cos(lambda2) * phi1))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]}, If[LessEqual[phi2, -0.00115], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi2, 52000000000.0], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 25: 48.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_2 \leq -0.39 \lor \neg \left(\phi_2 \leq 5.6 \cdot 10^{+20}\right):\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_0 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_2 \cdot \sin \phi_1\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* (cos phi1) (sin phi2))))
   (if (or (<= phi2 -0.39) (not (<= phi2 5.6e+20)))
     (atan2
      (* (sin lambda1) (cos phi2))
      (- t_0 (* phi1 (cos (- lambda2 lambda1)))))
     (atan2
      (sin (- lambda1 lambda2))
      (- t_0 (* (cos phi2) (* (cos lambda2) (sin phi1))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = cos(phi1) * sin(phi2);
	double tmp;
	if ((phi2 <= -0.39) || !(phi2 <= 5.6e+20)) {
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
	} else {
		tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: tmp
    t_0 = cos(phi1) * sin(phi2)
    if ((phi2 <= (-0.39d0)) .or. (.not. (phi2 <= 5.6d+20))) then
        tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))))
    else
        tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if ((phi2 <= -0.39) || !(phi2 <= 5.6e+20)) {
		tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), (t_0 - (phi1 * Math.cos((lambda2 - lambda1)))));
	} else {
		tmp = Math.atan2(Math.sin((lambda1 - lambda2)), (t_0 - (Math.cos(phi2) * (Math.cos(lambda2) * Math.sin(phi1)))));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if (phi2 <= -0.39) or not (phi2 <= 5.6e+20):
		tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), (t_0 - (phi1 * math.cos((lambda2 - lambda1)))))
	else:
		tmp = math.atan2(math.sin((lambda1 - lambda2)), (t_0 - (math.cos(phi2) * (math.cos(lambda2) * math.sin(phi1)))))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if ((phi2 <= -0.39) || !(phi2 <= 5.6e+20))
		tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_0 - Float64(phi1 * cos(Float64(lambda2 - lambda1)))));
	else
		tmp = atan(sin(Float64(lambda1 - lambda2)), Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda2) * sin(phi1)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if ((phi2 <= -0.39) || ~((phi2 <= 5.6e+20)))
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
	else
		tmp = atan2(sin((lambda1 - lambda2)), (t_0 - (cos(phi2) * (cos(lambda2) * sin(phi1)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi2, -0.39], N[Not[LessEqual[phi2, 5.6e+20]], $MachinePrecision]], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 26: 32.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\\ t_1 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\phi_1 \leq -3.25 \cdot 10^{-52}:\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1}{t_1 - \cos \phi_2 \cdot \left|t_0\right|}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_1 - t_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* phi1 (cos (- lambda2 lambda1))))
        (t_1 (* (cos phi1) (sin phi2))))
   (if (<= phi1 -3.25e-52)
     (atan2 (sin lambda1) (- t_1 (* (cos phi2) (fabs t_0))))
     (atan2 (* (sin lambda1) (cos phi2)) (- t_1 t_0)))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = phi1 * cos((lambda2 - lambda1));
	double t_1 = cos(phi1) * sin(phi2);
	double tmp;
	if (phi1 <= -3.25e-52) {
		tmp = atan2(sin(lambda1), (t_1 - (cos(phi2) * fabs(t_0))));
	} else {
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = phi1 * cos((lambda2 - lambda1))
    t_1 = cos(phi1) * sin(phi2)
    if (phi1 <= (-3.25d-52)) then
        tmp = atan2(sin(lambda1), (t_1 - (cos(phi2) * abs(t_0))))
    else
        tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = phi1 * Math.cos((lambda2 - lambda1));
	double t_1 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if (phi1 <= -3.25e-52) {
		tmp = Math.atan2(Math.sin(lambda1), (t_1 - (Math.cos(phi2) * Math.abs(t_0))));
	} else {
		tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), (t_1 - t_0));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = phi1 * math.cos((lambda2 - lambda1))
	t_1 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if phi1 <= -3.25e-52:
		tmp = math.atan2(math.sin(lambda1), (t_1 - (math.cos(phi2) * math.fabs(t_0))))
	else:
		tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), (t_1 - t_0))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(phi1 * cos(Float64(lambda2 - lambda1)))
	t_1 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if (phi1 <= -3.25e-52)
		tmp = atan(sin(lambda1), Float64(t_1 - Float64(cos(phi2) * abs(t_0))));
	else
		tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_1 - t_0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = phi1 * cos((lambda2 - lambda1));
	t_1 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if (phi1 <= -3.25e-52)
		tmp = atan2(sin(lambda1), (t_1 - (cos(phi2) * abs(t_0))));
	else
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -3.25e-52], N[ArcTan[N[Sin[lambda1], $MachinePrecision] / N[(t$95$1 - N[(N[Cos[phi2], $MachinePrecision] * N[Abs[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - t$95$0), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 27: 30.9% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\\ t_1 := \cos \phi_1 \cdot \sin \phi_2\\ \mathbf{if}\;\lambda_2 \leq -7.8 \cdot 10^{-22}:\\ \;\;\;\;\tan^{-1}_* \frac{\lambda_1 \cdot \cos \phi_2}{t_1 - \cos \phi_2 \cdot t_0}\\ \mathbf{else}:\\ \;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_1 - t_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (let* ((t_0 (* phi1 (cos (- lambda2 lambda1))))
        (t_1 (* (cos phi1) (sin phi2))))
   (if (<= lambda2 -7.8e-22)
     (atan2 (* lambda1 (cos phi2)) (- t_1 (* (cos phi2) t_0)))
     (atan2 (* (sin lambda1) (cos phi2)) (- t_1 t_0)))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = phi1 * cos((lambda2 - lambda1));
	double t_1 = cos(phi1) * sin(phi2);
	double tmp;
	if (lambda2 <= -7.8e-22) {
		tmp = atan2((lambda1 * cos(phi2)), (t_1 - (cos(phi2) * t_0)));
	} else {
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = phi1 * cos((lambda2 - lambda1))
    t_1 = cos(phi1) * sin(phi2)
    if (lambda2 <= (-7.8d-22)) then
        tmp = atan2((lambda1 * cos(phi2)), (t_1 - (cos(phi2) * t_0)))
    else
        tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	double t_0 = phi1 * Math.cos((lambda2 - lambda1));
	double t_1 = Math.cos(phi1) * Math.sin(phi2);
	double tmp;
	if (lambda2 <= -7.8e-22) {
		tmp = Math.atan2((lambda1 * Math.cos(phi2)), (t_1 - (Math.cos(phi2) * t_0)));
	} else {
		tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), (t_1 - t_0));
	}
	return tmp;
}

Python

def code(lambda1, lambda2, phi1, phi2):
	t_0 = phi1 * math.cos((lambda2 - lambda1))
	t_1 = math.cos(phi1) * math.sin(phi2)
	tmp = 0
	if lambda2 <= -7.8e-22:
		tmp = math.atan2((lambda1 * math.cos(phi2)), (t_1 - (math.cos(phi2) * t_0)))
	else:
		tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), (t_1 - t_0))
	return tmp

Julia

function code(lambda1, lambda2, phi1, phi2)
	t_0 = Float64(phi1 * cos(Float64(lambda2 - lambda1)))
	t_1 = Float64(cos(phi1) * sin(phi2))
	tmp = 0.0
	if (lambda2 <= -7.8e-22)
		tmp = atan(Float64(lambda1 * cos(phi2)), Float64(t_1 - Float64(cos(phi2) * t_0)));
	else
		tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_1 - t_0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, lambda2, phi1, phi2)
	t_0 = phi1 * cos((lambda2 - lambda1));
	t_1 = cos(phi1) * sin(phi2);
	tmp = 0.0;
	if (lambda2 <= -7.8e-22)
		tmp = atan2((lambda1 * cos(phi2)), (t_1 - (cos(phi2) * t_0)));
	else
		tmp = atan2((sin(lambda1) * cos(phi2)), (t_1 - t_0));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -7.8e-22], N[ArcTan[N[(lambda1 * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Cos[phi2], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - t$95$0), $MachinePrecision]], $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 28: 31.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (* (sin lambda1) (cos phi2))
  (- (* (cos phi1) (sin phi2)) (* phi1 (cos (- lambda2 lambda1))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2((sin(lambda1) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2((sin(lambda1) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), ((Math.cos(phi1) * Math.sin(phi2)) - (phi1 * Math.cos((lambda2 - lambda1)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2((math.sin(lambda1) * math.cos(phi2)), ((math.cos(phi1) * math.sin(phi2)) - (phi1 * math.cos((lambda2 - lambda1)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(Float64(sin(lambda1) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(phi1 * cos(Float64(lambda2 - lambda1)))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2((sin(lambda1) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 29: 23.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\sin \lambda_1}{\sin \phi_2 - \cos \phi_2 \cdot \left(\phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (sin lambda1)
  (- (sin phi2) (* (cos phi2) (* phi1 (cos (- lambda2 lambda1)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2(sin(lambda1), (sin(phi2) - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2(sin(lambda1), (sin(phi2) - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2(Math.sin(lambda1), (Math.sin(phi2) - (Math.cos(phi2) * (phi1 * Math.cos((lambda2 - lambda1))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2(math.sin(lambda1), (math.sin(phi2) - (math.cos(phi2) * (phi1 * math.cos((lambda2 - lambda1))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(sin(lambda1), Float64(sin(phi2) - Float64(cos(phi2) * Float64(phi1 * cos(Float64(lambda2 - lambda1))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2(sin(lambda1), (sin(phi2) - (cos(phi2) * (phi1 * cos((lambda2 - lambda1))))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[Sin[lambda1], $MachinePrecision] / N[(N[Sin[phi2], $MachinePrecision] - N[(N[Cos[phi2], $MachinePrecision] * N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 30: 23.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{\sin \lambda_1}{\cos \phi_1 \cdot \sin \phi_2 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (atan2
  (sin lambda1)
  (- (* (cos phi1) (sin phi2)) (* phi1 (cos (- lambda2 lambda1))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return atan2(sin(lambda1), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = atan2(sin(lambda1), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return Math.atan2(Math.sin(lambda1), ((Math.cos(phi1) * Math.sin(phi2)) - (phi1 * Math.cos((lambda2 - lambda1)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return math.atan2(math.sin(lambda1), ((math.cos(phi1) * math.sin(phi2)) - (phi1 * math.cos((lambda2 - lambda1)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return atan(sin(lambda1), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(phi1 * cos(Float64(lambda2 - lambda1)))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = atan2(sin(lambda1), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[Sin[lambda1], $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2024005 
(FPCore (lambda1 lambda2 phi1 phi2)
  :name "Bearing on a great circle"
  :precision binary64
  (atan2 (* (sin (- lambda1 lambda2)) (cos phi2)) (- (* (cos phi1) (sin phi2)) (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))